Changeset 3036


Ignore:
Timestamp:
Apr 16, 2013, 7:53:29 PM (6 years ago)
Author:
ksherdy
Message:

Updated all.pablob to compile.

Location:
proto/pabloj/trunk
Files:
3 edited

Legend:

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

    r2984 r3036  
    129129};     
    130130       
    131 kernel BasisBits
     131kernel Classify_bytes_Validate_utf8
    132132{
    133133        init
     
    485485                }       
    486486        }
     487        CarryDeclare(carry_set_0, 10, 0);       
    487488};     
    488489
     
    566567                }
    567568        }
     569       
     570        CarryDeclare(carry_set_0, 6, 0);
    568571};
    569572
     
    626629        }
    627630       
    628         // CarryDeclare(carry_set_0, 9, 0);
     631        CarryDeclare(carry_set_0, 9, 0);
    629632};
    630633 
     
    658661        }
    659662       
    660         // CarryDeclare(carry_set_0, 0, 0);
     663        CarryDeclare(carry_set_0, 0, 0);
    661664};
    662665
  • proto/pabloj/trunk/input/test/pabloB/proto/parabix2_pablo.pablob

    r3004 r3036  
     1// KERNEL kernelName LCURLY funcDef (optFuncDef)? RCURLY TERMINATOR?;
     2       
    13struct Basis_bits
    24{
     
    125127        BitBlock name_follows;
    126128        BitBlock att_refs;
    127 };
    128  
    129 kernel Classify_bytes_Validate_utf8
    130 {
    131         init
    132         {
    133                
    134         }
     129};     
     130       
     131kernel Classify_bytes_Validate_utf8 
     132{
     133        init
     134        {
    135135         
    136         function void do_block(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8)
     136        }
     137
     138        function void do_block(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8)
    137139        {
    138140                var BitBlock temp1 = simd.or<1>(basis_bits.bit_0, basis_bits.bit_1);
     
    229231                lex.Hex = simd.or<1>(temp62, temp65);
    230232                var BitBlock lex_error = simd.andc<1>(x00_x1F, lex.WS);
    231                 if (bitblock.any<1>(lex_error))
     233
     234                if (bitblock.any<1>((lex_error)))
    232235                {
    233236                        assert_0_error("Error: illegal character", lex_error);
     
    238241                var BitBlock u8_FFFE_FFFF = simd.constant<1>(0);
    239242                var BitBlock u8anyscope = simd.constant<1>(0);
    240                 if (bitblock.any<1>(simd.or<1>(basis_bits.bit_0, carry_set_0.CarryRange(0, 10))))
     243                if (bitblock.any<1>((simd.or<1>(basis_bits.bit_0, carry_set_0.CarryRange(0, 10)))))
    241244                {
    242245                        u8.prefix = simd.and<1>(basis_bits.bit_0, basis_bits.bit_1);
     
    253256                        u8.badprefix = simd.or<1>(temp68, temp71);
    254257                        u8_error = u8.badprefix;
    255                         u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2, carry_set_0.GetCarry(0), 0);
     258                        u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2, carry_set_0.CarryAt(0), 0);
    256259                        u8anyscope = u8.scope22;
    257                         if (bitblock.any<1>(simd.or<1>(simd.or<1>(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9))))
     260                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9)))))
    258261                        {
    259262                                var BitBlock xE0 = simd.andc<1>(u8.prefix3, temp36);
     
    270273                                u8.xBF = simd.and<1>(temp73, temp23);
    271274                                u8.xBE = simd.and<1>(temp73, temp15);
    272                                 u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3, carry_set_0.GetCarry(1), 1);
    273                                 u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32, carry_set_0.GetCarry(2), 2);
    274                                 u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4, carry_set_0.GetCarry(3), 3);
    275                                 u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.GetCarry(4), 4);
    276                                 u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.GetCarry(5), 5);
    277                                 var BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xE0, xF0), carry_set_0.GetCarry(6), 6);
    278                                 var BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xED, xF4), carry_set_0.GetCarry(7), 7);
     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                                var BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xE0, xF0), carry_set_0.CarryAt(6), 6);
     281                                var BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xED, xF4), carry_set_0.CarryAt(7), 7);
    279282                                u8.xE0_scope = simd.and<1>(u8.scope32, E0_F0_scope);
    280283                                u8.xED_scope = simd.and<1>(u8.scope32, ED_F4_scope);
    281284                                u8.xF0_scope = simd.and<1>(u8.scope42, E0_F0_scope);
    282285                                u8.xF4_scope = simd.and<1>(u8.scope42, ED_F4_scope);
    283                                 u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.GetCarry(8), 8);
     286                                u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.CarryAt(8), 8);
    284287                                var BitBlock u8lastscope = simd.or<1>(simd.or<1>(u8.scope22, u8.scope33), u8.scope44);
    285288                                u8anyscope = simd.or<1>(simd.or<1>(simd.or<1>(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
     
    289292                                var BitBlock u8error4 = simd.and<1>(u8.xF4_scope, u8.x90_xBF);
    290293                                u8_error = simd.or<1>(u8_error, simd.or<1>(simd.or<1>(simd.or<1>(u8error1, u8error2), u8error3), u8error4));
    291                                 var BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd.and<1>(u8.xEF_scope, u8.xBF), carry_set_0.GetCarry(9), 9);
     294                                var 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);
    292295                                u8_FFFE_FFFF = simd.and<1>(EF_BF_pending, simd.or<1>(u8.xBE, u8.xBF));
    293296                        }
     
    297300                        }
    298301                        var BitBlock u8mismatch = simd.xor<1>(u8anyscope, u8.suffix);
    299                         if (bitblock.any<1>(simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF)))
     302                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF))))
    300303                        {
    301304                                assert_0_error("UTF-8 error found", simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF));
     
    307310                }
    308311                carry_set_0.CarryAdjust(10);
    309         }
    310        
    311         function void do_final_block(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8, BitBlock EOF_mask)
    312         {
     312
     313        }
     314
     315        function void do_final_block(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8, BitBlock EOF_mask) {
    313316                var BitBlock temp1 = simd.or<1>(basis_bits.bit_0, basis_bits.bit_1);
    314317                var BitBlock temp2 = simd.andc<1>(basis_bits.bit_2, basis_bits.bit_3);
     
    404407                lex.Hex = simd.or<1>(temp62, temp65);
    405408                var BitBlock lex_error = simd.andc<1>(x00_x1F, lex.WS);
    406                 if (bitblock.any<1>(simd.and<1>(lex_error, EOF_mask)))
     409                if (bitblock.any<1>((simd.and<1>(lex_error, EOF_mask))))
    407410                {
    408411                        assert_0_error("Error: illegal character", simd.and<1>(lex_error, EOF_mask));
     
    413416                var BitBlock u8_FFFE_FFFF = simd.constant<1>(0);
    414417                var BitBlock u8anyscope = simd.constant<1>(0);
    415                 if (bitblock.any<1>(simd.or<1>(basis_bits.bit_0, carry_set_0.CarryRange(0, 10))))
     418                if (bitblock.any<1>((simd.or<1>(basis_bits.bit_0, carry_set_0.CarryRange(0, 10)))))
    416419                {
    417420                        u8.prefix = simd.and<1>(basis_bits.bit_0, basis_bits.bit_1);
     
    428431                        u8.badprefix = simd.or<1>(temp68, temp71);
    429432                        u8_error = u8.badprefix;
    430                         u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2, carry_set_0.GetCarry(0), 0);
     433                        u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2, carry_set_0.CarryAt(0), 0);
    431434                        u8anyscope = u8.scope22;
    432                         if (bitblock.any<1>(simd.or<1>(simd.or<1>(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9))))
     435                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9)))))
    433436                        {
    434437                                var BitBlock xE0 = simd.andc<1>(u8.prefix3, temp36);
     
    445448                                u8.xBF = simd.and<1>(temp73, temp23);
    446449                                u8.xBE = simd.and<1>(temp73, temp15);
    447                                 u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3, carry_set_0.GetCarry(1), 1);
    448                                 u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32, carry_set_0.GetCarry(2), 2);
    449                                 u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4, carry_set_0.GetCarry(3), 3);
    450                                 u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.GetCarry(4), 4);
    451                                 u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.GetCarry(5), 5);
    452                                 var BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xE0, xF0), carry_set_0.GetCarry(6), 6);
    453                                 var BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xED, xF4), carry_set_0.GetCarry(7), 7);
     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                                var BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xE0, xF0), carry_set_0.CarryAt(6), 6);
     456                                var BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xED, xF4), carry_set_0.CarryAt(7), 7);
    454457                                u8.xE0_scope = simd.and<1>(u8.scope32, E0_F0_scope);
    455458                                u8.xED_scope = simd.and<1>(u8.scope32, ED_F4_scope);
    456459                                u8.xF0_scope = simd.and<1>(u8.scope42, E0_F0_scope);
    457460                                u8.xF4_scope = simd.and<1>(u8.scope42, ED_F4_scope);
    458                                 u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.GetCarry(8), 8);
     461                                u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.CarryAt(8), 8);
    459462                                var BitBlock u8lastscope = simd.or<1>(simd.or<1>(u8.scope22, u8.scope33), u8.scope44);
    460463                                u8anyscope = simd.or<1>(simd.or<1>(simd.or<1>(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
     
    464467                                var BitBlock u8error4 = simd.and<1>(u8.xF4_scope, u8.x90_xBF);
    465468                                u8_error = simd.or<1>(u8_error, simd.or<1>(simd.or<1>(simd.or<1>(u8error1, u8error2), u8error3), u8error4));
    466                                 var BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd.and<1>(u8.xEF_scope, u8.xBF), carry_set_0.GetCarry(9), 9);
     469                                var 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);
    467470                                u8_FFFE_FFFF = simd.and<1>(EF_BF_pending, simd.or<1>(u8.xBE, u8.xBF));
    468471                        }
     
    472475                        }
    473476                        var BitBlock u8mismatch = simd.xor<1>(u8anyscope, u8.suffix);
    474                         if (bitblock.any<1>(simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF)))
     477                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF))))
    475478                        {
    476479                                assert_0_error("UTF-8 error found", simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF));
     
    480483                {
    481484                        carry_set_0.CarryDequeueEnqueue(0, 10);
    482                 }
    483         }
    484        
    485         CarryDeclare(carry_set_0, 10, 0);
    486 };
    487  
    488 kernel Parse_CtCDPI
     485                }       
     486        }
     487        CarryDeclare(carry_set_0, 10, 0);       
     488};     
     489
     490kernel Parse_refs
    489491{
    490492        init
    491493        {
    492                 carry_set_0.SetCarry(carry_set_0.CarryFlip(carry_set_0.GetCarry(2),2));
    493         }
    494          
    495         function void do_block(struct Lex lex, struct Marker marker, struct CtCDPI_Callouts ctCDPI_Callouts, struct Check_streams check_streams)
    496         {
    497                 ctCDPI_Callouts.Ct_starts = simd.constant<1>(0);
    498                 ctCDPI_Callouts.Ct_ends = simd.constant<1>(0);
    499                 ctCDPI_Callouts.CD_starts = simd.constant<1>(0);
    500                 ctCDPI_Callouts.CD_ends = simd.constant<1>(0);
    501                 ctCDPI_Callouts.PI_starts = simd.constant<1>(0);
    502                 ctCDPI_Callouts.PI_name_starts = simd.constant<1>(0);
    503                 ctCDPI_Callouts.PI_name_ends = simd.constant<1>(0);
    504                 ctCDPI_Callouts.PI_ends = simd.constant<1>(0);
    505                 var BitBlock CtCDPI_starts = simd.constant<1>(0);
    506                 var BitBlock CtCDPI_ends = simd.constant<1>(0);
    507                 var BitBlock ctCDPI_mask = simd.constant<1>(0);
    508                 var BitBlock v = simd.or<1>(lex.LAngle, lex.Hyphen);
    509                 var BitBlock w = simd.or<1>(lex.Hyphen, lex.QMark);
    510                 var BitBlock v1 = carry_set_0.BitBlock_advance_n_<1>(v, carry_set_0.Pending64(0), 0);
    511                 var BitBlock w1 = carry_set_0.BitBlock_advance_n_<1>(w, carry_set_0.Pending64(1), 1);
    512                 var BitBlock LAngle_scope = simd.andc<1>(v1, w1);
    513                 var BitBlock PI_opener = simd.and<1>(LAngle_scope, lex.QMark);
    514                 var BitBlock CtCD_opener = simd.and<1>(LAngle_scope, lex.Exclam);
    515                 var BitBlock CtCDPI_opener = simd.or<1>(PI_opener, CtCD_opener);
    516                 var BitBlock CD_closer = simd.constant<1>(0);
    517                 var BitBlock DoubleHyphen = simd.and<1>(simd.and<1>(v1, w1), lex.Hyphen);
    518                 if (bitblock.any<1>(simd.or<1>(lex.RBracket, carry_set_0.CarryRange(0, 2))))
    519                 {
    520                         var BitBlock DoubleRBracket = simd.and<1>(carry_set_0.BitBlock_advance_ci_co(lex.RBracket, carry_set_0.GetCarry(0), 0), lex.RBracket);
    521                         CD_closer = simd.and<1>(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket, carry_set_0.GetCarry(1), 1), lex.RAngle);
    522                 }
    523                 else
    524                 {
    525                         carry_set_0.CarryDequeueEnqueue(0, 2);
    526                 }
    527                 var BitBlock PI_closer = simd.and<1>(simd.andc<1>(w1, v1), lex.RAngle);
    528                 var BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener, carry_set_0.GetCarry(2), 2);
    529                 if (bitblock.any<1>(simd.or<1>(CtCDPI_Cursor, carry_set_0.CarryRange(3, 13))))
    530                 {
    531                         CtCDPI_starts = simd.or<1>(CtCDPI_starts, CtCDPI_Cursor);
    532                         var BitBlock PI_Cursor = simd.and<1>(CtCDPI_Cursor, PI_opener);
    533                         var BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd.andc<1>(CtCDPI_Cursor, PI_Cursor), carry_set_0.GetCarry(3), 3);
    534                         var BitBlock CD_Cursor = simd.and<1>(CD_Ct_Cursor, lex.LBracket);
    535                         var BitBlock Ct_Cursor = simd.and<1>(CD_Ct_Cursor, lex.Hyphen);
    536                         if (bitblock.any<1>(simd.or<1>(PI_Cursor, carry_set_0.CarryRange(4, 4))))
    537                         {
    538                                 ctCDPI_Callouts.PI_starts = simd.or<1>(ctCDPI_Callouts.PI_starts, PI_Cursor);
    539                                 PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor, carry_set_0.GetCarry(4), 4);
    540                                 ctCDPI_Callouts.PI_name_starts = simd.or<1>(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
    541                                 var BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carry_set_0.GetCarry(5), 5);
    542                                 var BitBlock PI_error = simd.and<1>(PI_Cursor, PI_name_end);
    543                                 var BitBlock PI_noWS = simd.andc<1>(PI_name_end, lex.WS);
    544                                 PI_error = simd.or<1>(PI_error, simd.or<1>(simd.andc<1>(PI_noWS, lex.QMark), simd.andc<1>(carry_set_0.BitBlock_advance_ci_co(PI_noWS, carry_set_0.GetCarry(6), 6), PI_closer)));
    545                                 if (bitblock.any<1>(PI_error))
    546                                 {
    547                                         assert_0_error("Error in PI syntax", PI_error);
    548                                 }
    549                                 ctCDPI_Callouts.PI_name_ends = simd.or<1>(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    550                                 PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end, simd.not<1>(PI_closer), carry_set_0.GetCarry(7), 7);
    551                                 ctCDPI_Callouts.PI_ends = simd.or<1>(ctCDPI_Callouts.PI_ends, PI_Cursor);
    552                                 CtCDPI_ends = simd.or<1>(CtCDPI_ends, PI_Cursor);
    553                         }
    554                         else
    555                         {
    556                                 carry_set_0.CarryDequeueEnqueue(4, 4);
    557                         }
    558                         if (bitblock.any<1>(simd.or<1>(CD_Cursor, carry_set_0.CarryRange(8, 1))))
    559                         {
    560                                 ctCDPI_Callouts.CD_starts = simd.or<1>(ctCDPI_Callouts.CD_starts, CD_Cursor);
    561                                 CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor, simd.not<1>(CD_closer), carry_set_0.GetCarry(8), 8);
    562                                 ctCDPI_Callouts.CD_ends = simd.or<1>(ctCDPI_Callouts.CD_ends, CD_Cursor);
    563                                 CtCDPI_ends = simd.or<1>(CtCDPI_ends, CD_Cursor);
    564                         }
    565                         else
    566                         {
    567                                 carry_set_0.CarryDequeueEnqueue(8, 1);
    568                         }
    569                         if (bitblock.any<1>(simd.or<1>(Ct_Cursor, carry_set_0.CarryRange(9, 5))))
    570                         {
    571                                 ctCDPI_Callouts.Ct_starts = simd.or<1>(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
    572                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.GetCarry(9), 9);
    573                                 var BitBlock Ct_error = simd.andc<1>(Ct_Cursor, lex.Hyphen);
    574                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.GetCarry(10), 10), carry_set_0.GetCarry(11), 11);
    575                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_scanthru_ci_co(Ct_Cursor, simd.not<1>(DoubleHyphen), carry_set_0.GetCarry(12), 12), carry_set_0.GetCarry(13), 13);
    576                                 if (bitblock.any<1>(simd.or<1>(Ct_error, simd.andc<1>(Ct_Cursor, lex.RAngle))))
    577                                 {
    578                                         assert_0_error("Error in comment syntax", simd.or<1>(Ct_error, simd.andc<1>(Ct_Cursor, lex.RAngle)));
    579                                 }
    580                                 ctCDPI_Callouts.Ct_ends = simd.or<1>(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
    581                                 CtCDPI_ends = simd.or<1>(CtCDPI_ends, Ct_Cursor);
    582                         }
    583                         else
    584                         {
    585                                 carry_set_0.CarryDequeueEnqueue(9, 5);
    586                         }
    587                         CtCDPI_Cursor = simd.or<1>(simd.or<1>(PI_Cursor, CD_Cursor), Ct_Cursor);
    588                         ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, carry_set_0.GetCarry(14), 14);
    589                         if (bitblock.any<1>(simd.constant<1>(0)))
    590                         {
    591                                 assert_0_error("Error in comment, CDATA or processing instruction syntax", simd.constant<1>(0));
    592                         }
    593                         CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd.not<1>(CtCDPI_opener), carry_set_0.GetCarry(15), 15);
    594                         while (bitblock.any<1>(CtCDPI_Cursor))
    595                         {
    596                                 CarryDeclare(carry_set_1, 13, 0);
    597                                 CtCDPI_starts = simd.or<1>(CtCDPI_starts, CtCDPI_Cursor);
    598                                 var BitBlock PI_Cursor = simd.and<1>(CtCDPI_Cursor, PI_opener);
    599                                 var BitBlock CD_Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(simd.andc<1>(CtCDPI_Cursor, PI_Cursor), simd.constant<1>(0), 0);
    600                                 var BitBlock CD_Cursor = simd.and<1>(CD_Ct_Cursor, lex.LBracket);
    601                                 var BitBlock Ct_Cursor = simd.and<1>(CD_Ct_Cursor, lex.Hyphen);
    602                                 if (bitblock.any<1>(PI_Cursor))
    603                                 {
    604                                         ctCDPI_Callouts.PI_starts = simd.or<1>(ctCDPI_Callouts.PI_starts, PI_Cursor);
    605                                         PI_Cursor = carry_set_1.BitBlock_advance_ci_co(PI_Cursor, simd.constant<1>(0), 1);
    606                                         ctCDPI_Callouts.PI_name_starts = simd.or<1>(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
    607                                         var BitBlock PI_name_end = carry_set_1.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, simd.constant<1>(0), 2);
    608                                         var BitBlock PI_error = simd.and<1>(PI_Cursor, PI_name_end);
    609                                         var BitBlock PI_noWS = simd.andc<1>(PI_name_end, lex.WS);
    610                                         PI_error = simd.or<1>(PI_error, simd.or<1>(simd.andc<1>(PI_noWS, lex.QMark), simd.andc<1>(carry_set_1.BitBlock_advance_ci_co(PI_noWS, simd.constant<1>(0), 3), PI_closer)));
    611                                         if (bitblock.any<1>(PI_error))
    612                                         {
    613                                                 assert_0_error("Error in PI syntax", PI_error);
    614                                         }
    615                                         ctCDPI_Callouts.PI_name_ends = simd.or<1>(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    616                                         PI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(PI_name_end, simd.not<1>(PI_closer), simd.constant<1>(0), 4);
    617                                         ctCDPI_Callouts.PI_ends = simd.or<1>(ctCDPI_Callouts.PI_ends, PI_Cursor);
    618                                         CtCDPI_ends = simd.or<1>(CtCDPI_ends, PI_Cursor);
    619                                 }
    620                                 if (bitblock.any<1>(CD_Cursor))
    621                                 {
    622                                         ctCDPI_Callouts.CD_starts = simd.or<1>(ctCDPI_Callouts.CD_starts, CD_Cursor);
    623                                         CD_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CD_Cursor, simd.not<1>(CD_closer), simd.constant<1>(0), 5);
    624                                         ctCDPI_Callouts.CD_ends = simd.or<1>(ctCDPI_Callouts.CD_ends, CD_Cursor);
    625                                         CtCDPI_ends = simd.or<1>(CtCDPI_ends, CD_Cursor);
    626                                 }
    627                                 if (bitblock.any<1>(Ct_Cursor))
    628                                 {
    629                                         ctCDPI_Callouts.Ct_starts = simd.or<1>(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
    630                                         Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(Ct_Cursor, simd.constant<1>(0), 6);
    631                                         var BitBlock Ct_error = simd.andc<1>(Ct_Cursor, lex.Hyphen);
    632                                         Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_advance_ci_co(Ct_Cursor, simd.constant<1>(0), 7), simd.constant<1>(0), 8);
    633                                         Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_scanthru_ci_co(Ct_Cursor, simd.not<1>(DoubleHyphen), simd.constant<1>(0), 9), simd.constant<1>(0), 10);
    634                                         if (bitblock.any<1>(simd.or<1>(Ct_error, simd.andc<1>(Ct_Cursor, lex.RAngle))))
    635                                         {
    636                                                 assert_0_error("Error in comment syntax", simd.or<1>(Ct_error, simd.andc<1>(Ct_Cursor, lex.RAngle)));
    637                                         }
    638                                         ctCDPI_Callouts.Ct_ends = simd.or<1>(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
    639                                         CtCDPI_ends = simd.or<1>(CtCDPI_ends, Ct_Cursor);
    640                                 }
    641                                 CtCDPI_Cursor = simd.or<1>(simd.or<1>(PI_Cursor, CD_Cursor), Ct_Cursor);
    642                                 ctCDPI_mask = carry_set_1.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, simd.constant<1>(0), 11);
    643                                 if (bitblock.any<1>(simd.constant<1>(0)))
    644                                 {
    645                                         assert_0_error("Error in comment, CDATA or processing instruction syntax", simd.constant<1>(0));
    646                                 }
    647                                 CtCDPI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd.not<1>(CtCDPI_opener), simd.constant<1>(0), 12);
    648                                 carry_set_0.CarryCombine(carry_set_1.cq, 3, 13);
    649                         }
    650                 }
    651                 else
    652                 {
    653                         carry_set_0.CarryDequeueEnqueue(3, 13);
    654                 }
    655                 check_streams.misc_mask = simd.and<1>(simd.or<1>(simd.or<1>(simd.or<1>(lex.WS, lex.LAngle), carry_set_0.BitBlock_inclusive_span(simd.or<1>(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd.or<1>(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carry_set_0.GetCarry(16), 16)), CtCDPI_starts), EOF_mask);
    656                 marker.LAngle_scope = simd.andc<1>(LAngle_scope, ctCDPI_mask);
    657                 marker.Ref_opener = simd.andc<1>(lex.RefStart, ctCDPI_mask);
    658                 marker.CD_closer = simd.andc<1>(CD_closer, ctCDPI_mask);
    659                 carry_set_0.CarryAdjust(17);
    660         }
    661        
    662         function void do_final_block(struct Lex lex, struct Marker marker, struct CtCDPI_Callouts ctCDPI_Callouts, struct Check_streams check_streams, BitBlock EOF_mask)
    663         {
    664                 ctCDPI_Callouts.Ct_starts = simd.constant<1>(0);
    665                 ctCDPI_Callouts.Ct_ends = simd.constant<1>(0);
    666                 ctCDPI_Callouts.CD_starts = simd.constant<1>(0);
    667                 ctCDPI_Callouts.CD_ends = simd.constant<1>(0);
    668                 ctCDPI_Callouts.PI_starts = simd.constant<1>(0);
    669                 ctCDPI_Callouts.PI_name_starts = simd.constant<1>(0);
    670                 ctCDPI_Callouts.PI_name_ends = simd.constant<1>(0);
    671                 ctCDPI_Callouts.PI_ends = simd.constant<1>(0);
    672                 var BitBlock CtCDPI_starts = simd.constant<1>(0);
    673                 var BitBlock CtCDPI_ends = simd.constant<1>(0);
    674                 var BitBlock ctCDPI_mask = simd.constant<1>(0);
    675                 var BitBlock v = simd.or<1>(lex.LAngle, lex.Hyphen);
    676                 var BitBlock w = simd.or<1>(lex.Hyphen, lex.QMark);
    677                 var BitBlock v1 = carry_set_0.BitBlock_advance_n_<1>(v, carry_set_0.Pending64(0), 0);
    678                 var BitBlock w1 = carry_set_0.BitBlock_advance_n_<1>(w, carry_set_0.Pending64(1), 1);
    679                 var BitBlock LAngle_scope = simd.andc<1>(v1, w1);
    680                 var BitBlock PI_opener = simd.and<1>(LAngle_scope, lex.QMark);
    681                 var BitBlock CtCD_opener = simd.and<1>(LAngle_scope, lex.Exclam);
    682                 var BitBlock CtCDPI_opener = simd.or<1>(PI_opener, CtCD_opener);
    683                 var BitBlock CD_closer = simd.constant<1>(0);
    684                 var BitBlock DoubleHyphen = simd.and<1>(simd.and<1>(v1, w1), lex.Hyphen);
    685                 if (bitblock.any<1>(simd.or<1>(lex.RBracket, carry_set_0.CarryRange(0, 2))))
    686                 {
    687                         var BitBlock DoubleRBracket = simd.and<1>(carry_set_0.BitBlock_advance_ci_co(lex.RBracket, carry_set_0.GetCarry(0), 0), lex.RBracket);
    688                         CD_closer = simd.and<1>(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket, carry_set_0.GetCarry(1), 1), lex.RAngle);
    689                 }
    690                 else
    691                 {
    692                         carry_set_0.CarryDequeueEnqueue(0, 2);
    693                 }
    694                 var BitBlock PI_closer = simd.and<1>(simd.andc<1>(w1, v1), lex.RAngle);
    695                 var BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener, carry_set_0.GetCarry(2), 2);
    696                 if (bitblock.any<1>(simd.or<1>(simd.and<1>(CtCDPI_Cursor, EOF_mask), carry_set_0.CarryRange(3, 13))))
    697                 {
    698                         CtCDPI_starts = simd.or<1>(CtCDPI_starts, CtCDPI_Cursor);
    699                         var BitBlock PI_Cursor = simd.and<1>(CtCDPI_Cursor, PI_opener);
    700                         var BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd.andc<1>(CtCDPI_Cursor, PI_Cursor), carry_set_0.GetCarry(3), 3);
    701                         var BitBlock CD_Cursor = simd.and<1>(CD_Ct_Cursor, lex.LBracket);
    702                         var BitBlock Ct_Cursor = simd.and<1>(CD_Ct_Cursor, lex.Hyphen);
    703                         if (bitblock.any<1>(simd.or<1>(PI_Cursor, carry_set_0.CarryRange(4, 4))))
    704                         {
    705                                 ctCDPI_Callouts.PI_starts = simd.or<1>(ctCDPI_Callouts.PI_starts, PI_Cursor);
    706                                 PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor, carry_set_0.GetCarry(4), 4);
    707                                 ctCDPI_Callouts.PI_name_starts = simd.or<1>(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
    708                                 var BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carry_set_0.GetCarry(5), 5);
    709                                 var BitBlock PI_error = simd.and<1>(PI_Cursor, PI_name_end);
    710                                 var BitBlock PI_noWS = simd.andc<1>(PI_name_end, lex.WS);
    711                                 PI_error = simd.or<1>(PI_error, simd.or<1>(simd.andc<1>(PI_noWS, lex.QMark), simd.andc<1>(carry_set_0.BitBlock_advance_ci_co(PI_noWS, carry_set_0.GetCarry(6), 6), PI_closer)));
    712                                 if (bitblock.any<1>(PI_error))
    713                                 {
    714                                         assert_0_error("Error in PI syntax", PI_error);
    715                                 }
    716                                 ctCDPI_Callouts.PI_name_ends = simd.or<1>(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    717                                 PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end, simd.andc<1>(EOF_mask, PI_closer), carry_set_0.GetCarry(7), 7);
    718                                 ctCDPI_Callouts.PI_ends = simd.or<1>(ctCDPI_Callouts.PI_ends, PI_Cursor);
    719                                 CtCDPI_ends = simd.or<1>(CtCDPI_ends, PI_Cursor);
    720                         }
    721                         else
    722                         {
    723                                 carry_set_0.CarryDequeueEnqueue(4, 4);
    724                         }
    725                         if (bitblock.any<1>(simd.or<1>(CD_Cursor, carry_set_0.CarryRange(8, 1))))
    726                         {
    727                                 ctCDPI_Callouts.CD_starts = simd.or<1>(ctCDPI_Callouts.CD_starts, CD_Cursor);
    728                                 CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor, simd.andc<1>(EOF_mask, CD_closer), carry_set_0.GetCarry(8), 8);
    729                                 ctCDPI_Callouts.CD_ends = simd.or<1>(ctCDPI_Callouts.CD_ends, CD_Cursor);
    730                                 CtCDPI_ends = simd.or<1>(CtCDPI_ends, CD_Cursor);
    731                         }
    732                         else
    733                         {
    734                                 carry_set_0.CarryDequeueEnqueue(8, 1);
    735                         }
    736                         if (bitblock.any<1>(simd.or<1>(Ct_Cursor, carry_set_0.CarryRange(9, 5))))
    737                         {
    738                                 ctCDPI_Callouts.Ct_starts = simd.or<1>(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
    739                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.GetCarry(9), 9);
    740                                 var BitBlock Ct_error = simd.andc<1>(Ct_Cursor, lex.Hyphen);
    741                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.GetCarry(10), 10), carry_set_0.GetCarry(11), 11);
    742                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_scanthru_ci_co(Ct_Cursor, simd.andc<1>(EOF_mask, DoubleHyphen), carry_set_0.GetCarry(12), 12), carry_set_0.GetCarry(13), 13);
    743                                 if (bitblock.any<1>(simd.or<1>(Ct_error, simd.andc<1>(Ct_Cursor, lex.RAngle))))
    744                                 {
    745                                         assert_0_error("Error in comment syntax", simd.or<1>(Ct_error, simd.andc<1>(Ct_Cursor, lex.RAngle)));
    746                                 }
    747                                 ctCDPI_Callouts.Ct_ends = simd.or<1>(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
    748                                 CtCDPI_ends = simd.or<1>(CtCDPI_ends, Ct_Cursor);
    749                         }
    750                         else
    751                         {
    752                                 carry_set_0.CarryDequeueEnqueue(9, 5);
    753                         }
    754                         CtCDPI_Cursor = simd.or<1>(simd.or<1>(PI_Cursor, CD_Cursor), Ct_Cursor);
    755                         ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, carry_set_0.GetCarry(14), 14);
    756                         if (bitblock.any<1>(simd.andc<1>(ctCDPI_mask, EOF_mask)))
    757                         {
    758                                 assert_0_error("Error in comment, CDATA or processing instruction syntax", simd.andc<1>(ctCDPI_mask, EOF_mask));
    759                         }
    760                         CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd.andc<1>(EOF_mask, CtCDPI_opener), carry_set_0.GetCarry(15), 15);
    761                         while (bitblock.any<1>(simd.and<1>(CtCDPI_Cursor, EOF_mask)))
    762                         {
    763                                 CarryDeclare(carry_set_1, 13, 0);
    764                                 CtCDPI_starts = simd.or<1>(CtCDPI_starts, CtCDPI_Cursor);
    765                                 var BitBlock PI_Cursor = simd.and<1>(CtCDPI_Cursor, PI_opener);
    766                                 var BitBlock CD_Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(simd.andc<1>(CtCDPI_Cursor, PI_Cursor), simd.constant<1>(0), 0);
    767                                 var BitBlock CD_Cursor = simd.and<1>(CD_Ct_Cursor, lex.LBracket);
    768                                 var BitBlock Ct_Cursor = simd.and<1>(CD_Ct_Cursor, lex.Hyphen);
    769                                 if (bitblock.any<1>(PI_Cursor))
    770                                 {
    771                                         ctCDPI_Callouts.PI_starts = simd.or<1>(ctCDPI_Callouts.PI_starts, PI_Cursor);
    772                                         PI_Cursor = carry_set_1.BitBlock_advance_ci_co(PI_Cursor, simd.constant<1>(0), 1);
    773                                         ctCDPI_Callouts.PI_name_starts = simd.or<1>(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
    774                                         var BitBlock PI_name_end = carry_set_1.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, simd.constant<1>(0), 2);
    775                                         var BitBlock PI_error = simd.and<1>(PI_Cursor, PI_name_end);
    776                                         var BitBlock PI_noWS = simd.andc<1>(PI_name_end, lex.WS);
    777                                         PI_error = simd.or<1>(PI_error, simd.or<1>(simd.andc<1>(PI_noWS, lex.QMark), simd.andc<1>(carry_set_1.BitBlock_advance_ci_co(PI_noWS, simd.constant<1>(0), 3), PI_closer)));
    778                                         if (bitblock.any<1>(PI_error))
    779                                         {
    780                                                 assert_0_error("Error in PI syntax", PI_error);
    781                                         }
    782                                         ctCDPI_Callouts.PI_name_ends = simd.or<1>(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    783                                         PI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(PI_name_end, simd.andc<1>(EOF_mask, PI_closer), simd.constant<1>(0), 4);
    784                                         ctCDPI_Callouts.PI_ends = simd.or<1>(ctCDPI_Callouts.PI_ends, PI_Cursor);
    785                                         CtCDPI_ends = simd.or<1>(CtCDPI_ends, PI_Cursor);
    786                                 }
    787                                 if (bitblock.any<1>(CD_Cursor))
    788                                 {
    789                                         ctCDPI_Callouts.CD_starts = simd.or<1>(ctCDPI_Callouts.CD_starts, CD_Cursor);
    790                                         CD_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CD_Cursor, simd.andc<1>(EOF_mask, CD_closer), simd.constant<1>(0), 5);
    791                                         ctCDPI_Callouts.CD_ends = simd.or<1>(ctCDPI_Callouts.CD_ends, CD_Cursor);
    792                                         CtCDPI_ends = simd.or<1>(CtCDPI_ends, CD_Cursor);
    793                                 }
    794                                 if (bitblock.any<1>(Ct_Cursor))
    795                                 {
    796                                         ctCDPI_Callouts.Ct_starts = simd.or<1>(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
    797                                         Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(Ct_Cursor, simd.constant<1>(0), 6);
    798                                         var BitBlock Ct_error = simd.andc<1>(Ct_Cursor, lex.Hyphen);
    799                                         Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_advance_ci_co(Ct_Cursor, simd.constant<1>(0), 7), simd.constant<1>(0), 8);
    800                                         Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_scanthru_ci_co(Ct_Cursor, simd.andc<1>(EOF_mask, DoubleHyphen), simd.constant<1>(0), 9), simd.constant<1>(0), 10);
    801                                         if (bitblock.any<1>(simd.or<1>(Ct_error, simd.andc<1>(Ct_Cursor, lex.RAngle))))
    802                                         {
    803                                                 assert_0_error("Error in comment syntax", simd.or<1>(Ct_error, simd.andc<1>(Ct_Cursor, lex.RAngle)));
    804                                         }
    805                                         ctCDPI_Callouts.Ct_ends = simd.or<1>(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
    806                                         CtCDPI_ends = simd.or<1>(CtCDPI_ends, Ct_Cursor);
    807                                 }
    808                                 CtCDPI_Cursor = simd.or<1>(simd.or<1>(PI_Cursor, CD_Cursor), Ct_Cursor);
    809                                 ctCDPI_mask = carry_set_1.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, simd.constant<1>(0), 11);
    810                                 if (bitblock.any<1>(simd.andc<1>(ctCDPI_mask, EOF_mask)))
    811                                 {
    812                                         assert_0_error("Error in comment, CDATA or processing instruction syntax", simd.andc<1>(ctCDPI_mask, EOF_mask));
    813                                 }
    814                                 CtCDPI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd.andc<1>(EOF_mask, CtCDPI_opener), simd.constant<1>(0), 12);
    815                                 carry_set_0.CarryCombine(carry_set_1.cq, 3, 13);
    816                         }
    817                 }
    818                 else
    819                 {
    820                         carry_set_0.CarryDequeueEnqueue(3, 13);
    821                 }
    822                 check_streams.misc_mask = simd.and<1>(simd.or<1>(simd.or<1>(simd.or<1>(lex.WS, lex.LAngle), carry_set_0.BitBlock_inclusive_span(simd.or<1>(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd.or<1>(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carry_set_0.GetCarry(16), 16)), CtCDPI_starts), EOF_mask);
    823                 marker.LAngle_scope = simd.andc<1>(LAngle_scope, ctCDPI_mask);
    824                 marker.Ref_opener = simd.andc<1>(lex.RefStart, ctCDPI_mask);
    825                 marker.CD_closer = simd.andc<1>(CD_closer, ctCDPI_mask);
    826         }
    827        
    828         CarryDeclare(carry_set_0, 17, 2);
    829 };
    830  
    831 kernel Parse_tags
    832 {
    833         init
    834         {
    835494               
    836         }
    837          
    838         function void do_block(struct Lex lex, struct Marker marker, struct Tag_Callouts tag_Callouts)
    839         {
    840                 var BitBlock EqExpected = simd.constant<1>(0);
    841                 var BitBlock AttListEnd = simd.constant<1>(0);
    842                 var BitBlock DQuoteDelim = simd.or<1>(lex.DQuote, lex.LAngle);
    843                 var BitBlock SQuoteDelim = simd.or<1>(lex.SQuote, lex.LAngle);
    844                 var BitBlock AttListDelim = simd.or<1>(lex.Slash, lex.RAngle);
    845                 tag_Callouts.ElemName_starts = simd.andc<1>(marker.LAngle_scope, lex.Slash);
    846                 tag_Callouts.EndTag_marks = simd.and<1>(marker.LAngle_scope, lex.Slash);
    847                 tag_Callouts.ElemName_ends = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts, lex.NameScan, carry_set_0.GetCarry(0), 0);
    848                 var BitBlock ParseError = simd.and<1>(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
    849                 tag_Callouts.AttName_starts = simd.constant<1>(0);
    850                 tag_Callouts.AttName_ends = simd.constant<1>(0);
    851                 tag_Callouts.AttVal_starts = simd.constant<1>(0);
    852                 tag_Callouts.AttVal_ends = simd.constant<1>(0);
    853                 if (bitblock.any<1>(simd.or<1>(simd.and<1>(tag_Callouts.ElemName_ends, lex.WS), carry_set_0.CarryRange(1, 8))))
    854                 {
    855                         var BitBlock AfterWS = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends, lex.WS, carry_set_0.GetCarry(1), 1);
    856                         AttListEnd = simd.and<1>(AfterWS, AttListDelim);
    857                         var BitBlock AttNameStart = simd.andc<1>(AfterWS, AttListDelim);
    858                         if (bitblock.any<1>(simd.or<1>(AttNameStart, carry_set_0.CarryRange(2, 7))))
    859                         {
    860                                 ParseError = simd.or<1>(ParseError, simd.andc<1>(AttNameStart, lex.NameScan));
    861                                 tag_Callouts.AttName_starts = simd.or<1>(tag_Callouts.AttName_starts, AttNameStart);
    862                                 var BitBlock AttNameFollow = carry_set_0.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carry_set_0.GetCarry(2), 2);
    863                                 tag_Callouts.AttName_ends = simd.or<1>(tag_Callouts.AttName_ends, AttNameFollow);
    864                                 if (bitblock.any<1>(simd.or<1>(simd.and<1>(AttNameFollow, lex.WS), carry_set_0.CarryRange(3, 1))))
    865                                 {
    866                                         EqExpected = carry_set_0.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carry_set_0.GetCarry(3), 3);
    867                                 }
    868                                 else
    869                                 {
    870                                         EqExpected = AttNameFollow;
    871                                         carry_set_0.CarryDequeueEnqueue(3, 1);
    872                                 }
    873                                 ParseError = simd.or<1>(ParseError, simd.andc<1>(EqExpected, lex.Equals));
    874                                 var BitBlock AttValPos = carry_set_0.BitBlock_advance_then_scanthru(EqExpected, lex.WS, carry_set_0.GetCarry(4), 4);
    875                                 tag_Callouts.AttVal_starts = simd.or<1>(tag_Callouts.AttVal_starts, AttValPos);
    876                                 var BitBlock DQuoteAttVal = simd.and<1>(AttValPos, lex.DQuote);
    877                                 var BitBlock SQuoteAttVal = simd.and<1>(AttValPos, lex.SQuote);
    878                                 var BitBlock DQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(DQuoteAttVal, simd.not<1>(DQuoteDelim), carry_set_0.GetCarry(5), 5);
    879                                 var BitBlock SQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(SQuoteAttVal, simd.not<1>(SQuoteDelim), carry_set_0.GetCarry(6), 6);
    880                                 var BitBlock AttValEnd = simd.or<1>(DQuoteAttEnd, SQuoteAttEnd);
    881                                 ParseError = simd.or<1>(ParseError, simd.andc<1>(simd.or<1>(AttValPos, AttValEnd), simd.or<1>(lex.DQuote, lex.SQuote)));
    882                                 var BitBlock AttValFollow = carry_set_0.BitBlock_advance_ci_co(AttValEnd, carry_set_0.GetCarry(7), 7);
    883                                 tag_Callouts.AttVal_ends = simd.or<1>(tag_Callouts.AttVal_ends, AttValFollow);
    884                                 if (bitblock.any<1>(simd.or<1>(simd.and<1>(AttValFollow, lex.WS), carry_set_0.CarryRange(8, 1))))
    885                                 {
    886                                         AfterWS = carry_set_0.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carry_set_0.GetCarry(8), 8);
    887                                         AttListEnd = simd.or<1>(AttListEnd, simd.and<1>(AfterWS, AttListDelim));
    888                                         AttNameStart = simd.andc<1>(AfterWS, AttListDelim);
    889                                 }
    890                                 else
    891                                 {
    892                                         AttListEnd = simd.or<1>(AttListEnd, simd.and<1>(AttValFollow, AttListDelim));
    893                                         AttNameStart = simd.andc<1>(AttValFollow, AttListDelim);
    894                                         carry_set_0.CarryDequeueEnqueue(8, 1);
    895                                 }
    896                                 ParseError = simd.or<1>(ParseError, simd.and<1>(AttValFollow, AttNameStart));
    897                                 while (bitblock.any<1>(AttNameStart))
    898                                 {
    899                                         CarryDeclare(carry_set_1, 7, 0);
    900                                         ParseError = simd.or<1>(ParseError, simd.andc<1>(AttNameStart, lex.NameScan));
    901                                         tag_Callouts.AttName_starts = simd.or<1>(tag_Callouts.AttName_starts, AttNameStart);
    902                                         var BitBlock AttNameFollow = carry_set_1.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, simd.constant<1>(0), 0);
    903                                         tag_Callouts.AttName_ends = simd.or<1>(tag_Callouts.AttName_ends, AttNameFollow);
    904                                         if (bitblock.any<1>(simd.and<1>(AttNameFollow, lex.WS)))
    905                                         {
    906                                                 EqExpected = carry_set_1.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, simd.constant<1>(0), 1);
    907                                         }
    908                                         else
    909                                         {
    910                                                 EqExpected = AttNameFollow;
    911                                         }
    912                                         ParseError = simd.or<1>(ParseError, simd.andc<1>(EqExpected, lex.Equals));
    913                                         var BitBlock AttValPos = carry_set_1.BitBlock_advance_then_scanthru(EqExpected, lex.WS, simd.constant<1>(0), 2);
    914                                         tag_Callouts.AttVal_starts = simd.or<1>(tag_Callouts.AttVal_starts, AttValPos);
    915                                         var BitBlock DQuoteAttVal = simd.and<1>(AttValPos, lex.DQuote);
    916                                         var BitBlock SQuoteAttVal = simd.and<1>(AttValPos, lex.SQuote);
    917                                         var BitBlock DQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(DQuoteAttVal, simd.not<1>(DQuoteDelim), simd.constant<1>(0), 3);
    918                                         var BitBlock SQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(SQuoteAttVal, simd.not<1>(SQuoteDelim), simd.constant<1>(0), 4);
    919                                         var BitBlock AttValEnd = simd.or<1>(DQuoteAttEnd, SQuoteAttEnd);
    920                                         ParseError = simd.or<1>(ParseError, simd.andc<1>(simd.or<1>(AttValPos, AttValEnd), simd.or<1>(lex.DQuote, lex.SQuote)));
    921                                         var BitBlock AttValFollow = carry_set_1.BitBlock_advance_ci_co(AttValEnd, simd.constant<1>(0), 5);
    922                                         tag_Callouts.AttVal_ends = simd.or<1>(tag_Callouts.AttVal_ends, AttValFollow);
    923                                         if (bitblock.any<1>(simd.and<1>(AttValFollow, lex.WS)))
    924                                         {
    925                                                 AfterWS = carry_set_1.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, simd.constant<1>(0), 6);
    926                                                 AttListEnd = simd.or<1>(AttListEnd, simd.and<1>(AfterWS, AttListDelim));
    927                                                 AttNameStart = simd.andc<1>(AfterWS, AttListDelim);
    928                                         }
    929                                         else
    930                                         {
    931                                                 AttListEnd = simd.or<1>(AttListEnd, simd.and<1>(AttValFollow, AttListDelim));
    932                                                 AttNameStart = simd.andc<1>(AttValFollow, AttListDelim);
    933                                         }
    934                                         ParseError = simd.or<1>(ParseError, simd.and<1>(AttValFollow, AttNameStart));
    935                                         carry_set_0.CarryCombine(carry_set_1.cq, 2, 7);
    936                                 }
    937                         }
    938                         else
    939                         {
    940                                 carry_set_0.CarryDequeueEnqueue(2, 7);
    941                         }
    942                 }
    943                 else
    944                 {
    945                         AttListEnd = simd.and<1>(tag_Callouts.ElemName_ends, AttListDelim);
    946                         ParseError = simd.or<1>(ParseError, simd.andc<1>(tag_Callouts.ElemName_ends, AttListDelim));
    947                         carry_set_0.CarryDequeueEnqueue(1, 8);
    948                 }
    949                 var BitBlock STagEnds = simd.and<1>(AttListEnd, lex.RAngle);
    950                 tag_Callouts.EmptyTag_marks = carry_set_0.BitBlock_advance_ci_co(simd.and<1>(AttListEnd, lex.Slash), carry_set_0.GetCarry(9), 9);
    951                 ParseError = simd.or<1>(ParseError, simd.andc<1>(tag_Callouts.EmptyTag_marks, lex.RAngle));
    952                 var BitBlock EndTagEnds = carry_set_0.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks, lex.NameScan, carry_set_0.GetCarry(10), 10);
    953                 if (bitblock.any<1>(simd.or<1>(simd.and<1>(EndTagEnds, lex.WS), carry_set_0.CarryRange(11, 1))))
    954                 {
    955                         EndTagEnds = carry_set_0.BitBlock_scanthru_ci_co(EndTagEnds, lex.WS, carry_set_0.GetCarry(11), 11);
    956                 }
    957                 else
    958                 {
    959                         carry_set_0.CarryDequeueEnqueue(11, 1);
    960                 }
    961                 ParseError = simd.or<1>(ParseError, simd.andc<1>(EndTagEnds, lex.RAngle));
    962                 if (bitblock.any<1>(ParseError))
    963                 {
    964                         assert_0_error("Tag parsing error found", ParseError);
    965                 }
    966                 tag_Callouts.AttVal_spans = carry_set_0.BitBlock_span_upto(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carry_set_0.GetCarry(12), 12);
    967                 carry_set_0.CarryAdjust(13);
    968         }
    969        
    970         function void do_final_block(struct Lex lex, struct Marker marker, struct Tag_Callouts tag_Callouts, BitBlock EOF_mask)
    971         {
    972                 var BitBlock EqExpected = simd.constant<1>(0);
    973                 var BitBlock AttListEnd = simd.constant<1>(0);
    974                 var BitBlock DQuoteDelim = simd.or<1>(lex.DQuote, lex.LAngle);
    975                 var BitBlock SQuoteDelim = simd.or<1>(lex.SQuote, lex.LAngle);
    976                 var BitBlock AttListDelim = simd.or<1>(lex.Slash, lex.RAngle);
    977                 tag_Callouts.ElemName_starts = simd.andc<1>(marker.LAngle_scope, lex.Slash);
    978                 tag_Callouts.EndTag_marks = simd.and<1>(marker.LAngle_scope, lex.Slash);
    979                 tag_Callouts.ElemName_ends = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts, lex.NameScan, carry_set_0.GetCarry(0), 0);
    980                 var BitBlock ParseError = simd.and<1>(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
    981                 tag_Callouts.AttName_starts = simd.constant<1>(0);
    982                 tag_Callouts.AttName_ends = simd.constant<1>(0);
    983                 tag_Callouts.AttVal_starts = simd.constant<1>(0);
    984                 tag_Callouts.AttVal_ends = simd.constant<1>(0);
    985                 if (bitblock.any<1>(simd.or<1>(simd.and<1>(tag_Callouts.ElemName_ends, lex.WS), carry_set_0.CarryRange(1, 8))))
    986                 {
    987                         var BitBlock AfterWS = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends, lex.WS, carry_set_0.GetCarry(1), 1);
    988                         AttListEnd = simd.and<1>(AfterWS, AttListDelim);
    989                         var BitBlock AttNameStart = simd.andc<1>(AfterWS, AttListDelim);
    990                         if (bitblock.any<1>(simd.or<1>(simd.and<1>(AttNameStart, EOF_mask), carry_set_0.CarryRange(2, 7))))
    991                         {
    992                                 ParseError = simd.or<1>(ParseError, simd.andc<1>(AttNameStart, lex.NameScan));
    993                                 tag_Callouts.AttName_starts = simd.or<1>(tag_Callouts.AttName_starts, AttNameStart);
    994                                 var BitBlock AttNameFollow = carry_set_0.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carry_set_0.GetCarry(2), 2);
    995                                 tag_Callouts.AttName_ends = simd.or<1>(tag_Callouts.AttName_ends, AttNameFollow);
    996                                 if (bitblock.any<1>(simd.or<1>(simd.and<1>(AttNameFollow, lex.WS), carry_set_0.CarryRange(3, 1))))
    997                                 {
    998                                         EqExpected = carry_set_0.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carry_set_0.GetCarry(3), 3);
    999                                 }
    1000                                 else
    1001                                 {
    1002                                         EqExpected = AttNameFollow;
    1003                                         carry_set_0.CarryDequeueEnqueue(3, 1);
    1004                                 }
    1005                                 ParseError = simd.or<1>(ParseError, simd.andc<1>(EqExpected, lex.Equals));
    1006                                 var BitBlock AttValPos = carry_set_0.BitBlock_advance_then_scanthru(EqExpected, lex.WS, carry_set_0.GetCarry(4), 4);
    1007                                 tag_Callouts.AttVal_starts = simd.or<1>(tag_Callouts.AttVal_starts, AttValPos);
    1008                                 var BitBlock DQuoteAttVal = simd.and<1>(AttValPos, lex.DQuote);
    1009                                 var BitBlock SQuoteAttVal = simd.and<1>(AttValPos, lex.SQuote);
    1010                                 var BitBlock DQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(DQuoteAttVal, simd.andc<1>(EOF_mask, DQuoteDelim), carry_set_0.GetCarry(5), 5);
    1011                                 var BitBlock SQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(SQuoteAttVal, simd.andc<1>(EOF_mask, SQuoteDelim), carry_set_0.GetCarry(6), 6);
    1012                                 var BitBlock AttValEnd = simd.or<1>(DQuoteAttEnd, SQuoteAttEnd);
    1013                                 ParseError = simd.or<1>(ParseError, simd.andc<1>(simd.or<1>(AttValPos, AttValEnd), simd.or<1>(lex.DQuote, lex.SQuote)));
    1014                                 var BitBlock AttValFollow = carry_set_0.BitBlock_advance_ci_co(AttValEnd, carry_set_0.GetCarry(7), 7);
    1015                                 tag_Callouts.AttVal_ends = simd.or<1>(tag_Callouts.AttVal_ends, AttValFollow);
    1016                                 if (bitblock.any<1>(simd.or<1>(simd.and<1>(AttValFollow, lex.WS), carry_set_0.CarryRange(8, 1))))
    1017                                 {
    1018                                         AfterWS = carry_set_0.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carry_set_0.GetCarry(8), 8);
    1019                                         AttListEnd = simd.or<1>(AttListEnd, simd.and<1>(AfterWS, AttListDelim));
    1020                                         AttNameStart = simd.andc<1>(AfterWS, AttListDelim);
    1021                                 }
    1022                                 else
    1023                                 {
    1024                                         AttListEnd = simd.or<1>(AttListEnd, simd.and<1>(AttValFollow, AttListDelim));
    1025                                         AttNameStart = simd.andc<1>(AttValFollow, AttListDelim);
    1026                                         carry_set_0.CarryDequeueEnqueue(8, 1);
    1027                                 }
    1028                                 ParseError = simd.or<1>(ParseError, simd.and<1>(AttValFollow, AttNameStart));
    1029                                 while (bitblock.any<1>(simd.and<1>(AttNameStart, EOF_mask)))
    1030                                 {
    1031                                         CarryDeclare(carry_set_1, 7, 0);
    1032                                         ParseError = simd.or<1>(ParseError, simd.andc<1>(AttNameStart, lex.NameScan));
    1033                                         tag_Callouts.AttName_starts = simd.or<1>(tag_Callouts.AttName_starts, AttNameStart);
    1034                                         var BitBlock AttNameFollow = carry_set_1.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, simd.constant<1>(0), 0);
    1035                                         tag_Callouts.AttName_ends = simd.or<1>(tag_Callouts.AttName_ends, AttNameFollow);
    1036                                         if (bitblock.any<1>(simd.and<1>(AttNameFollow, lex.WS)))
    1037                                         {
    1038                                                 EqExpected = carry_set_1.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, simd.constant<1>(0), 1);
    1039                                         }
    1040                                         else
    1041                                         {
    1042                                                 EqExpected = AttNameFollow;
    1043                                         }
    1044                                         ParseError = simd.or<1>(ParseError, simd.andc<1>(EqExpected, lex.Equals));
    1045                                         var BitBlock AttValPos = carry_set_1.BitBlock_advance_then_scanthru(EqExpected, lex.WS, simd.constant<1>(0), 2);
    1046                                         tag_Callouts.AttVal_starts = simd.or<1>(tag_Callouts.AttVal_starts, AttValPos);
    1047                                         var BitBlock DQuoteAttVal = simd.and<1>(AttValPos, lex.DQuote);
    1048                                         var BitBlock SQuoteAttVal = simd.and<1>(AttValPos, lex.SQuote);
    1049                                         var BitBlock DQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(DQuoteAttVal, simd.andc<1>(EOF_mask, DQuoteDelim), simd.constant<1>(0), 3);
    1050                                         var BitBlock SQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(SQuoteAttVal, simd.andc<1>(EOF_mask, SQuoteDelim), simd.constant<1>(0), 4);
    1051                                         var BitBlock AttValEnd = simd.or<1>(DQuoteAttEnd, SQuoteAttEnd);
    1052                                         ParseError = simd.or<1>(ParseError, simd.andc<1>(simd.or<1>(AttValPos, AttValEnd), simd.or<1>(lex.DQuote, lex.SQuote)));
    1053                                         var BitBlock AttValFollow = carry_set_1.BitBlock_advance_ci_co(AttValEnd, simd.constant<1>(0), 5);
    1054                                         tag_Callouts.AttVal_ends = simd.or<1>(tag_Callouts.AttVal_ends, AttValFollow);
    1055                                         if (bitblock.any<1>(simd.and<1>(AttValFollow, lex.WS)))
    1056                                         {
    1057                                                 AfterWS = carry_set_1.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, simd.constant<1>(0), 6);
    1058                                                 AttListEnd = simd.or<1>(AttListEnd, simd.and<1>(AfterWS, AttListDelim));
    1059                                                 AttNameStart = simd.andc<1>(AfterWS, AttListDelim);
    1060                                         }
    1061                                         else
    1062                                         {
    1063                                                 AttListEnd = simd.or<1>(AttListEnd, simd.and<1>(AttValFollow, AttListDelim));
    1064                                                 AttNameStart = simd.andc<1>(AttValFollow, AttListDelim);
    1065                                         }
    1066                                         ParseError = simd.or<1>(ParseError, simd.and<1>(AttValFollow, AttNameStart));
    1067                                         carry_set_0.CarryCombine(carry_set_1.cq, 2, 7);
    1068                                 }
    1069                         }
    1070                         else
    1071                         {
    1072                                 carry_set_0.CarryDequeueEnqueue(2, 7);
    1073                         }
    1074                 }
    1075                 else
    1076                 {
    1077                         AttListEnd = simd.and<1>(tag_Callouts.ElemName_ends, AttListDelim);
    1078                         ParseError = simd.or<1>(ParseError, simd.andc<1>(tag_Callouts.ElemName_ends, AttListDelim));
    1079                         carry_set_0.CarryDequeueEnqueue(1, 8);
    1080                 }
    1081                 var BitBlock STagEnds = simd.and<1>(AttListEnd, lex.RAngle);
    1082                 tag_Callouts.EmptyTag_marks = carry_set_0.BitBlock_advance_ci_co(simd.and<1>(AttListEnd, lex.Slash), carry_set_0.GetCarry(9), 9);
    1083                 ParseError = simd.or<1>(ParseError, simd.andc<1>(tag_Callouts.EmptyTag_marks, lex.RAngle));
    1084                 var BitBlock EndTagEnds = carry_set_0.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks, lex.NameScan, carry_set_0.GetCarry(10), 10);
    1085                 if (bitblock.any<1>(simd.or<1>(simd.and<1>(EndTagEnds, lex.WS), carry_set_0.CarryRange(11, 1))))
    1086                 {
    1087                         EndTagEnds = carry_set_0.BitBlock_scanthru_ci_co(EndTagEnds, lex.WS, carry_set_0.GetCarry(11), 11);
    1088                 }
    1089                 else
    1090                 {
    1091                         carry_set_0.CarryDequeueEnqueue(11, 1);
    1092                 }
    1093                 ParseError = simd.or<1>(ParseError, simd.andc<1>(EndTagEnds, lex.RAngle));
    1094                 if (bitblock.any<1>(ParseError))
    1095                 {
    1096                         assert_0_error("Tag parsing error found", ParseError);
    1097                 }
    1098                 tag_Callouts.AttVal_spans = carry_set_0.BitBlock_span_upto(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carry_set_0.GetCarry(12), 12);
    1099         }
    1100        
    1101         CarryDeclare(carry_set_0, 13, 0);       
    1102        
    1103 };
    1104  
    1105 kernel Parse_refs
    1106 {
    1107         init
    1108         {
    1109                        
    1110495        }
    1111496         
     
    1119504                ref_Callouts.HexRef_ends = simd.constant<1>(0);
    1120505                var BitBlock ref_error = simd.constant<1>(0);
    1121                 if (bitblock.any<1>(simd.or<1>(marker.Ref_opener, carry_set_0.CarryRange(0, 6))))
    1122                 {
    1123                         var BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.GetCarry(0), 0);
     506                if (bitblock.any<1>((simd.or<1>(marker.Ref_opener, carry_set_0.CarryRange(0, 6)))))
     507                {
     508                        var BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.CarryAt(0), 0);
    1124509                        var BitBlock NumRef2 = simd.and<1>(Ref_scope, lex.Hash);
    1125510                        ref_Callouts.GenRef_starts = simd.andc<1>(Ref_scope, lex.Hash);
    1126                         var BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.GetCarry(1), 1);
     511                        var BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.CarryAt(1), 1);
    1127512                        var BitBlock HexRef3 = simd.and<1>(NumRef3, lex.x);
    1128513                        ref_Callouts.DecRef_starts = simd.andc<1>(NumRef3, lex.x);
    1129                         ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.GetCarry(2), 2);
    1130                         ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carry_set_0.GetCarry(3), 3);
    1131                         ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.GetCarry(4), 4);
    1132                         ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.GetCarry(5), 5);
     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);
    1133518                        var BitBlock ref_error1 = simd.andc<1>(ref_Callouts.DecRef_starts, lex.Digit);
    1134519                        var BitBlock ref_error2 = simd.andc<1>(ref_Callouts.HexRef_starts, lex.Hex);
    1135520                        var BitBlock ref_ends = simd.or<1>(simd.or<1>(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
    1136521                        var BitBlock ref_error3 = simd.andc<1>(ref_ends, lex.Semicolon);
    1137                         if (bitblock.any<1>(simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3)))
     522                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3))))
    1138523                        {
    1139524                                assert_0_error("Reference error found", simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3));
     
    1156541                ref_Callouts.HexRef_ends = simd.constant<1>(0);
    1157542                var BitBlock ref_error = simd.constant<1>(0);
    1158                 if (bitblock.any<1>(simd.or<1>(marker.Ref_opener, carry_set_0.CarryRange(0, 6))))
    1159                 {
    1160                         var BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.GetCarry(0), 0);
     543                if (bitblock.any<1>((simd.or<1>(marker.Ref_opener, carry_set_0.CarryRange(0, 6)))))
     544                {
     545                        var BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.CarryAt(0), 0);
    1161546                        var BitBlock NumRef2 = simd.and<1>(Ref_scope, lex.Hash);
    1162547                        ref_Callouts.GenRef_starts = simd.andc<1>(Ref_scope, lex.Hash);
    1163                         var BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.GetCarry(1), 1);
     548                        var BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.CarryAt(1), 1);
    1164549                        var BitBlock HexRef3 = simd.and<1>(NumRef3, lex.x);
    1165550                        ref_Callouts.DecRef_starts = simd.andc<1>(NumRef3, lex.x);
    1166                         ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.GetCarry(2), 2);
    1167                         ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carry_set_0.GetCarry(3), 3);
    1168                         ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.GetCarry(4), 4);
    1169                         ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.GetCarry(5), 5);
     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);
    1170555                        var BitBlock ref_error1 = simd.andc<1>(ref_Callouts.DecRef_starts, lex.Digit);
    1171556                        var BitBlock ref_error2 = simd.andc<1>(ref_Callouts.HexRef_starts, lex.Hex);
    1172557                        var BitBlock ref_ends = simd.or<1>(simd.or<1>(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
    1173558                        var BitBlock ref_error3 = simd.andc<1>(ref_ends, lex.Semicolon);
    1174                         if (bitblock.any<1>(simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3)))
     559                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3))))
    1175560                        {
    1176561                                assert_0_error("Reference error found", simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3));
     
    1185570        CarryDeclare(carry_set_0, 6, 0);
    1186571};
    1187  
     572
    1188573kernel Validate_xml_names
    1189574{
    1190575        init
    1191576        {
    1192                        
     577               
    1193578        }
    1194579         
    1195580        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)
    1196581        {
    1197                 var BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.GetCarry(0), 0);
    1198                 var BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.GetCarry(1), 1);
    1199                 var BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.GetCarry(2), 2);
    1200                 var BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.GetCarry(3), 3);
     582                var 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                var BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.CarryAt(1), 1);
     584                var BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.CarryAt(2), 2);
     585                var BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.CarryAt(3), 3);
    1201586                var BitBlock qname_stream = simd.or<1>(ElemNames, AttNames);
    1202587                var BitBlock ncname_stream = simd.or<1>(PI_names, GenRefs);
    1203588                var BitBlock name_stream = simd.or<1>(qname_stream, ncname_stream);
    1204                 var BitBlock name_start = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.GetCarry(4), 4));
    1205                 var BitBlock name_cursor = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.GetCarry(5), 5));
     589                var BitBlock name_start = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(4), 4));
     590                var BitBlock name_cursor = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(5), 5));
    1206591                var BitBlock void_prefix_err = simd.and<1>(name_cursor, lex.Colon);
    1207                 var 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.GetCarry(6), 6), lex.Colon);
    1208                 var BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.GetCarry(7), 7);
     592                var 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                var BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.CarryAt(7), 7);
    1209594                var BitBlock local_part_err = simd.andc<1>(local_part_start, lex.NameScan);
    1210                 var 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.GetCarry(8), 8), lex.Colon);
     595                var 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);
    1211596                var BitBlock ncname_err = simd.and<1>(ncname_stream, lex.Colon);
    1212                 if (bitblock.any<1>(simd.or<1>(simd.or<1>(simd.or<1>(void_prefix_err, local_part_err), colon2_err), ncname_err)))
     597                if (bitblock.any<1>((simd.or<1>(simd.or<1>(simd.or<1>(void_prefix_err, local_part_err), colon2_err), ncname_err))))
    1213598                {
    1214599                        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));
     
    1221606        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)
    1222607        {
    1223                 var BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.GetCarry(0), 0);
    1224                 var BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.GetCarry(1), 1);
    1225                 var BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.GetCarry(2), 2);
    1226                 var BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.GetCarry(3), 3);
     608                var 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                var BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.CarryAt(1), 1);
     610                var BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.CarryAt(2), 2);
     611                var BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.CarryAt(3), 3);
    1227612                var BitBlock qname_stream = simd.or<1>(ElemNames, AttNames);
    1228613                var BitBlock ncname_stream = simd.or<1>(PI_names, GenRefs);
    1229614                var BitBlock name_stream = simd.or<1>(qname_stream, ncname_stream);
    1230                 var BitBlock name_start = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.GetCarry(4), 4));
    1231                 var BitBlock name_cursor = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.GetCarry(5), 5));
     615                var BitBlock name_start = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(4), 4));
     616                var BitBlock name_cursor = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(5), 5));
    1232617                var BitBlock void_prefix_err = simd.and<1>(name_cursor, lex.Colon);
    1233                 var 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.GetCarry(6), 6), lex.Colon);
    1234                 var BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.GetCarry(7), 7);
     618                var 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                var BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.CarryAt(7), 7);
    1235620                var BitBlock local_part_err = simd.andc<1>(local_part_start, lex.NameScan);
    1236                 var 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.GetCarry(8), 8), lex.Colon);
     621                var 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);
    1237622                var BitBlock ncname_err = simd.and<1>(ncname_stream, lex.Colon);
    1238                 if (bitblock.any<1>(simd.or<1>(simd.or<1>(simd.or<1>(void_prefix_err, local_part_err), colon2_err), ncname_err)))
     623                if (bitblock.any<1>((simd.or<1>(simd.or<1>(simd.or<1>(void_prefix_err, local_part_err), colon2_err), ncname_err))))
    1239624                {
    1240625                        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));
     
    1251636        init
    1252637        {
    1253                        
     638               
    1254639        }
    1255640         
    1256         function void do_block(struct Marker marker, struct Tag_Callouts tag_Callouts, struct Check_streams check_streams)
    1257         {
    1258                 if (bitblock.any<1>(simd.andc<1>(marker.CD_closer, tag_Callouts.AttVal_spans)))
     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))))
    1259644                {
    1260645                        assert_0_error("Error: ]]> in text", simd.andc<1>(marker.CD_closer, tag_Callouts.AttVal_spans));
     
    1267652        function void do_final_block(struct Marker marker, struct Tag_Callouts tag_Callouts, struct Check_streams check_streams, BitBlock EOF_mask)
    1268653        {
    1269                 if (bitblock.any<1>(simd.andc<1>(marker.CD_closer, tag_Callouts.AttVal_spans)))
     654                if (bitblock.any<1>((simd.andc<1>(marker.CD_closer, tag_Callouts.AttVal_spans))))
    1270655                {
    1271656                        assert_0_error("Error: ]]> in text", simd.andc<1>(marker.CD_closer, tag_Callouts.AttVal_spans));
     
    1278663        CarryDeclare(carry_set_0, 0, 0);
    1279664};
     665
  • proto/pabloj/trunk/output/cpplang/pablo_definitions.hpp

    r3029 r3036  
    2828#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
    2929BitBlock EOF_mask = simd<1>::constant<1>();
     30
    3031
    3132// XMLWF application headers and definitions
     
    7172                BitBlock k;
    7273                BitBlock r;
     74<<<<<<< .mine
     75                bool t;
     76                t = bitblock::any(a);
     77                r = bitblock::slli<10>(a);
     78                bitblock::store_unaligned(a, &b);
     79                r = bitblock::load_aligned(&b);
     80                r = simd_not(a);
     81                r = simd_nor(a, b);
     82                r = simd<16>::ifh(a, b, c);
     83                r = simd<2>::constant<3>();
     84                r = simd<8>::slli<1>(a);
     85                r = simd<1>::add(a, b);
     86                r = simd<2>::sub(a, b);
     87                r = simd<4>::mult(a, b);
     88                r = simd<8>::eq(a, b);
     89                r = simd<16>::gt(a, b);
     90                r = simd<32>::ugt(a, b);
     91                r = simd<64>::lt(a, b);
     92                r = simd<128>::ult(a, b);
     93                r = simd<128>::max(a, b);
     94                r = simd<1>::umax(a, b);
     95                r = simd<2>::min(a, b);
     96                r = simd<4>::umin(a, b);
     97                r = simd<64>::sll(a, b);
     98                r = simd<64>::srl(a, b);
     99=======
    73100                r = simd<1>::add(a, b);
    74101                r = simd<2>::sub(a, b);
     
    86113                r = simd<16>::srl(a, b);
    87114                r = simd<32>::sra(a, b);
     115>>>>>>> .r3035
    88116        }
    89117       
Note: See TracChangeset for help on using the changeset viewer.