Ignore:
Timestamp:
Jun 4, 2013, 12:33:12 AM (6 years ago)
Author:
ksherdy
Message:

Added PabloB state node and state parameters to Kernels.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/output/cpplang/pablo_definitions.hpp

    r3258 r3260  
    189189{
    190190        Classify_bytes_Validate_utf8()
    191         {}
     191        {
     192        }
     193         
    192194        IDISA_INLINE void do_block(struct Basis_bits & basis_bits,struct Lex & lex,struct U8 & u8)
    193195        {
     
    545547{
    546548        Parse_CtCDPI()
    547         {}
    548         IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams)
    549         {
    550                 ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
    551                 ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
    552                 ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
    553                 ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
    554                 ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
    555                 ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
    556                 ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
    557                 ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
    558                 BitBlock CtCDPI_starts = simd<1>::constant<0>();
    559                 BitBlock CtCDPI_ends = simd<1>::constant<0>();
    560                 BitBlock ctCDPI_mask = simd<1>::constant<0>();
    561                 BitBlock v = simd_or(lex.LAngle,lex.Hyphen);
    562                 BitBlock w = simd_or(lex.Hyphen,lex.QMark);
    563                 BitBlock v1 = carry_set_0.BitBlock_advance_n_<1>(v,carry_set_0.Pending64(0),0);
    564                 BitBlock w1 = carry_set_0.BitBlock_advance_n_<1>(w,carry_set_0.Pending64(1),1);
    565                 BitBlock LAngle_scope = simd_andc(v1,w1);
    566                 BitBlock PI_opener = simd_and(LAngle_scope,lex.QMark);
    567                 BitBlock CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
    568                 BitBlock CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
    569                 BitBlock CD_closer = simd<1>::constant<0>();
    570                 BitBlock DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
    571                 if (bitblock::any(simd_or(lex.RBracket,carry_set_0.CarryRange(0,2))))
    572                 {
    573                         BitBlock DoubleRBracket = simd_and(carry_set_0.BitBlock_advance_ci_co(lex.RBracket,carry_set_0.GetCarry(0),0),lex.RBracket);
    574                         CD_closer = simd_and(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket,carry_set_0.GetCarry(1),1),lex.RAngle);
    575                 }
    576                 else
    577                 {
    578                         carry_set_0.CarryDequeueEnqueue(0,2);
    579                 }
    580                 BitBlock PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
    581                 BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener,carry_set_0.GetCarry(2),2);
    582                 if (bitblock::any(simd_or(CtCDPI_Cursor,carry_set_0.CarryRange(3,13))))
    583                 {
    584                         CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
    585                         BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    586                         BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.GetCarry(3),3);
    587                         BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
    588                         BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    589                         if (bitblock::any(simd_or(PI_Cursor,carry_set_0.CarryRange(4,4))))
    590                         {
    591                                 ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
    592                                 PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor,carry_set_0.GetCarry(4),4);
    593                                 ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    594                                 BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor,lex.NameScan,carry_set_0.GetCarry(5),5);
    595                                 BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
    596                                 BitBlock PI_noWS = simd_andc(PI_name_end,lex.WS);
    597                                 PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(carry_set_0.BitBlock_advance_ci_co(PI_noWS,carry_set_0.GetCarry(6),6),PI_closer)));
    598                                 if (bitblock::any(PI_error))
    599                                 {
    600                                         assert_0_error("Error in PI syntax",PI_error);
    601                                 }
    602                                 ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
    603                                 PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end,simd_not(PI_closer),carry_set_0.GetCarry(7),7);
    604                                 ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    605                                 CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     549        {
     550                carry_set_0.SetCarry(carry_set_0.CarryFlip(carry_set_0.GetCarry(2)),2);
     551                }
     552                 
     553                IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams)
     554                {
     555                        ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
     556                        ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
     557                        ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
     558                        ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
     559                        ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
     560                        ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
     561                        ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
     562                        ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
     563                        BitBlock CtCDPI_starts = simd<1>::constant<0>();
     564                        BitBlock CtCDPI_ends = simd<1>::constant<0>();
     565                        BitBlock ctCDPI_mask = simd<1>::constant<0>();
     566                        BitBlock v = simd_or(lex.LAngle,lex.Hyphen);
     567                        BitBlock w = simd_or(lex.Hyphen,lex.QMark);
     568                        BitBlock v1 = carry_set_0.BitBlock_advance_n_<1>(v,carry_set_0.Pending64(0),0);
     569                        BitBlock w1 = carry_set_0.BitBlock_advance_n_<1>(w,carry_set_0.Pending64(1),1);
     570                        BitBlock LAngle_scope = simd_andc(v1,w1);
     571                        BitBlock PI_opener = simd_and(LAngle_scope,lex.QMark);
     572                        BitBlock CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
     573                        BitBlock CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
     574                        BitBlock CD_closer = simd<1>::constant<0>();
     575                        BitBlock DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
     576                        if (bitblock::any(simd_or(lex.RBracket,carry_set_0.CarryRange(0,2))))
     577                        {
     578                                BitBlock DoubleRBracket = simd_and(carry_set_0.BitBlock_advance_ci_co(lex.RBracket,carry_set_0.GetCarry(0),0),lex.RBracket);
     579                                CD_closer = simd_and(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket,carry_set_0.GetCarry(1),1),lex.RAngle);
    606580                        }
    607581                        else
    608582                        {
    609                                 carry_set_0.CarryDequeueEnqueue(4,4);
    610                         }
    611                         if (bitblock::any(simd_or(CD_Cursor,carry_set_0.CarryRange(8,1))))
    612                         {
    613                                 ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    614                                 CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor,simd_not(CD_closer),carry_set_0.GetCarry(8),8);
    615                                 ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    616                                 CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
    617                         }
    618                         else
    619                         {
    620                                 carry_set_0.CarryDequeueEnqueue(8,1);
    621                         }
    622                         if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.CarryRange(9,5))))
    623                         {
    624                                 ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
    625                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor,carry_set_0.GetCarry(9),9);
    626                                 BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    627                                 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);
    628                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_scanthru_ci_co(Ct_Cursor,simd_not(DoubleHyphen),carry_set_0.GetCarry(12),12),carry_set_0.GetCarry(13),13);
    629                                 if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    630                                 {
    631                                         assert_0_error("Error in comment syntax",simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)));
    632                                 }
    633                                 ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
    634                                 CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
    635                         }
    636                         else
    637                         {
    638                                 carry_set_0.CarryDequeueEnqueue(9,5);
    639                         }
    640                         CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
    641                         ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts,CtCDPI_ends,carry_set_0.GetCarry(14),14);
    642                         if (bitblock::any(simd<1>::constant<0>()))
    643                         {
    644                                 assert_0_error("Error in comment, CDATA or processing instruction syntax",simd<1>::constant<0>());
    645                         }
    646                         CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor,simd_not(CtCDPI_opener),carry_set_0.GetCarry(15),15);
    647                         while (bitblock::any(CtCDPI_Cursor))
    648                         {
    649                                 CarryDeclare(carry_set_1,13,0);
     583                                carry_set_0.CarryDequeueEnqueue(0,2);
     584                        }
     585                        BitBlock PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
     586                        BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener,carry_set_0.GetCarry(2),2);
     587                        if (bitblock::any(simd_or(CtCDPI_Cursor,carry_set_0.CarryRange(3,13))))
     588                        {
    650589                                CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
    651590                                BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    652                                 BitBlock CD_Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor,PI_Cursor),simd<1>::constant<0>(),0);
     591                                BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.GetCarry(3),3);
    653592                                BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
    654593                                BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    655                                 if (bitblock::any(PI_Cursor))
     594                                if (bitblock::any(simd_or(PI_Cursor,carry_set_0.CarryRange(4,4))))
    656595                                {
    657596                                        ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
    658                                         PI_Cursor = carry_set_1.BitBlock_advance_ci_co(PI_Cursor,simd<1>::constant<0>(),1);
     597                                        PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor,carry_set_0.GetCarry(4),4);
    659598                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    660                                         BitBlock PI_name_end = carry_set_1.BitBlock_scanthru_ci_co(PI_Cursor,lex.NameScan,simd<1>::constant<0>(),2);
     599                                        BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor,lex.NameScan,carry_set_0.GetCarry(5),5);
    661600                                        BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
    662601                                        BitBlock PI_noWS = simd_andc(PI_name_end,lex.WS);
    663                                         PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(carry_set_1.BitBlock_advance_ci_co(PI_noWS,simd<1>::constant<0>(),3),PI_closer)));
     602                                        PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(carry_set_0.BitBlock_advance_ci_co(PI_noWS,carry_set_0.GetCarry(6),6),PI_closer)));
    664603                                        if (bitblock::any(PI_error))
    665604                                        {
     
    667606                                        }
    668607                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
    669                                         PI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(PI_name_end,simd_not(PI_closer),simd<1>::constant<0>(),4);
     608                                        PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end,simd_not(PI_closer),carry_set_0.GetCarry(7),7);
    670609                                        ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    671610                                        CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
    672611                                }
    673                                 if (bitblock::any(CD_Cursor))
     612                                else
     613                                {
     614                                        carry_set_0.CarryDequeueEnqueue(4,4);
     615                                }
     616                                if (bitblock::any(simd_or(CD_Cursor,carry_set_0.CarryRange(8,1))))
    674617                                {
    675618                                        ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    676                                         CD_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CD_Cursor,simd_not(CD_closer),simd<1>::constant<0>(),5);
     619                                        CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor,simd_not(CD_closer),carry_set_0.GetCarry(8),8);
    677620                                        ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    678621                                        CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
    679622                                }
    680                                 if (bitblock::any(Ct_Cursor))
     623                                else
     624                                {
     625                                        carry_set_0.CarryDequeueEnqueue(8,1);
     626                                }
     627                                if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.CarryRange(9,5))))
    681628                                {
    682629                                        ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
    683                                         Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(Ct_Cursor,simd<1>::constant<0>(),6);
     630                                        Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor,carry_set_0.GetCarry(9),9);
    684631                                        BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    685                                         Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_advance_ci_co(Ct_Cursor,simd<1>::constant<0>(),7),simd<1>::constant<0>(),8);
    686                                         Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_scanthru_ci_co(Ct_Cursor,simd_not(DoubleHyphen),simd<1>::constant<0>(),9),simd<1>::constant<0>(),10);
     632                                        Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_advance_ci_co(Ct_Cursor,carry_set_0.GetCarry(10),10),carry_set_0.GetCarry(11),11);
     633                                        Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_scanthru_ci_co(Ct_Cursor,simd_not(DoubleHyphen),carry_set_0.GetCarry(12),12),carry_set_0.GetCarry(13),13);
    687634                                        if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    688635                                        {
     
    692639                                        CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
    693640                                }
     641                                else
     642                                {
     643                                        carry_set_0.CarryDequeueEnqueue(9,5);
     644                                }
    694645                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
    695                                 ctCDPI_mask = carry_set_1.BitBlock_inclusive_span(CtCDPI_starts,CtCDPI_ends,simd<1>::constant<0>(),11);
     646                                ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts,CtCDPI_ends,carry_set_0.GetCarry(14),14);
    696647                                if (bitblock::any(simd<1>::constant<0>()))
    697648                                {
    698649                                        assert_0_error("Error in comment, CDATA or processing instruction syntax",simd<1>::constant<0>());
    699650                                }
    700                                 CtCDPI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CtCDPI_Cursor,simd_not(CtCDPI_opener),simd<1>::constant<0>(),12);
    701                                 LocalCarryCombine(carry_set_0,carry_set_1,3,13);
    702                         }
    703                 }
    704                 else
    705                 {
    706                         carry_set_0.CarryDequeueEnqueue(3,13);
    707                 }
    708                 check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS,lex.LAngle),carry_set_0.BitBlock_inclusive_span(simd_or(ctCDPI_Callouts.Ct_starts,ctCDPI_Callouts.PI_starts),simd_or(ctCDPI_Callouts.Ct_ends,ctCDPI_Callouts.PI_ends),carry_set_0.GetCarry(16),16)),CtCDPI_starts),EOF_mask);
    709                 marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
    710                 marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
    711                 marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
    712                 carry_set_0.CarryAdjust(17);
    713         }
    714        
    715         void do_final_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams,BitBlock & EOF_mask)
    716         {
    717                 ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
    718                 ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
    719                 ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
    720                 ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
    721                 ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
    722                 ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
    723                 ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
    724                 ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
    725                 BitBlock CtCDPI_starts = simd<1>::constant<0>();
    726                 BitBlock CtCDPI_ends = simd<1>::constant<0>();
    727                 BitBlock ctCDPI_mask = simd<1>::constant<0>();
    728                 BitBlock v = simd_or(lex.LAngle,lex.Hyphen);
    729                 BitBlock w = simd_or(lex.Hyphen,lex.QMark);
    730                 BitBlock v1 = carry_set_0.BitBlock_advance_n_<1>(v,carry_set_0.Pending64(0),0);
    731                 BitBlock w1 = carry_set_0.BitBlock_advance_n_<1>(w,carry_set_0.Pending64(1),1);
    732                 BitBlock LAngle_scope = simd_andc(v1,w1);
    733                 BitBlock PI_opener = simd_and(LAngle_scope,lex.QMark);
    734                 BitBlock CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
    735                 BitBlock CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
    736                 BitBlock CD_closer = simd<1>::constant<0>();
    737                 BitBlock DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
    738                 if (bitblock::any(simd_or(lex.RBracket,carry_set_0.CarryRange(0,2))))
    739                 {
    740                         BitBlock DoubleRBracket = simd_and(carry_set_0.BitBlock_advance_ci_co(lex.RBracket,carry_set_0.GetCarry(0),0),lex.RBracket);
    741                         CD_closer = simd_and(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket,carry_set_0.GetCarry(1),1),lex.RAngle);
    742                 }
    743                 else
    744                 {
    745                         carry_set_0.CarryDequeueEnqueue(0,2);
    746                 }
    747                 BitBlock PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
    748                 BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener,carry_set_0.GetCarry(2),2);
    749                 if (bitblock::any(simd_or(simd_and(CtCDPI_Cursor,EOF_mask),carry_set_0.CarryRange(3,13))))
    750                 {
    751                         CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
    752                         BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    753                         BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.GetCarry(3),3);
    754                         BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
    755                         BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    756                         if (bitblock::any(simd_or(PI_Cursor,carry_set_0.CarryRange(4,4))))
    757                         {
    758                                 ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
    759                                 PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor,carry_set_0.GetCarry(4),4);
    760                                 ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    761                                 BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor,lex.NameScan,carry_set_0.GetCarry(5),5);
    762                                 BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
    763                                 BitBlock PI_noWS = simd_andc(PI_name_end,lex.WS);
    764                                 PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(carry_set_0.BitBlock_advance_ci_co(PI_noWS,carry_set_0.GetCarry(6),6),PI_closer)));
    765                                 if (bitblock::any(PI_error))
    766                                 {
    767                                         assert_0_error("Error in PI syntax",PI_error);
    768                                 }
    769                                 ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
    770                                 PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end,simd_andc(EOF_mask,PI_closer),carry_set_0.GetCarry(7),7);
    771                                 ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    772                                 CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     651                                CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor,simd_not(CtCDPI_opener),carry_set_0.GetCarry(15),15);
     652                                while (bitblock::any(CtCDPI_Cursor))
     653                                {
     654                                        CarryDeclare(carry_set_1,13,0);
     655                                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
     656                                        BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
     657                                        BitBlock CD_Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor,PI_Cursor),simd<1>::constant<0>(),0);
     658                                        BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
     659                                        BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
     660                                        if (bitblock::any(PI_Cursor))
     661                                        {
     662                                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
     663                                                PI_Cursor = carry_set_1.BitBlock_advance_ci_co(PI_Cursor,simd<1>::constant<0>(),1);
     664                                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
     665                                                BitBlock PI_name_end = carry_set_1.BitBlock_scanthru_ci_co(PI_Cursor,lex.NameScan,simd<1>::constant<0>(),2);
     666                                                BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
     667                                                BitBlock PI_noWS = simd_andc(PI_name_end,lex.WS);
     668                                                PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(carry_set_1.BitBlock_advance_ci_co(PI_noWS,simd<1>::constant<0>(),3),PI_closer)));
     669                                                if (bitblock::any(PI_error))
     670                                                {
     671                                                        assert_0_error("Error in PI syntax",PI_error);
     672                                                }
     673                                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
     674                                                PI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(PI_name_end,simd_not(PI_closer),simd<1>::constant<0>(),4);
     675                                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
     676                                                CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     677                                        }
     678                                        if (bitblock::any(CD_Cursor))
     679                                        {
     680                                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
     681                                                CD_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CD_Cursor,simd_not(CD_closer),simd<1>::constant<0>(),5);
     682                                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
     683                                                CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     684                                        }
     685                                        if (bitblock::any(Ct_Cursor))
     686                                        {
     687                                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
     688                                                Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(Ct_Cursor,simd<1>::constant<0>(),6);
     689                                                BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
     690                                                Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_advance_ci_co(Ct_Cursor,simd<1>::constant<0>(),7),simd<1>::constant<0>(),8);
     691                                                Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_scanthru_ci_co(Ct_Cursor,simd_not(DoubleHyphen),simd<1>::constant<0>(),9),simd<1>::constant<0>(),10);
     692                                                if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
     693                                                {
     694                                                        assert_0_error("Error in comment syntax",simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)));
     695                                                }
     696                                                ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
     697                                                CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
     698                                        }
     699                                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
     700                                        ctCDPI_mask = carry_set_1.BitBlock_inclusive_span(CtCDPI_starts,CtCDPI_ends,simd<1>::constant<0>(),11);
     701                                        if (bitblock::any(simd<1>::constant<0>()))
     702                                        {
     703                                                assert_0_error("Error in comment, CDATA or processing instruction syntax",simd<1>::constant<0>());
     704                                        }
     705                                        CtCDPI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CtCDPI_Cursor,simd_not(CtCDPI_opener),simd<1>::constant<0>(),12);
     706                                        LocalCarryCombine(carry_set_0,carry_set_1,3,13);
     707                                }
    773708                        }
    774709                        else
    775710                        {
    776                                 carry_set_0.CarryDequeueEnqueue(4,4);
    777                         }
    778                         if (bitblock::any(simd_or(CD_Cursor,carry_set_0.CarryRange(8,1))))
    779                         {
    780                                 ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    781                                 CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor,simd_andc(EOF_mask,CD_closer),carry_set_0.GetCarry(8),8);
    782                                 ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    783                                 CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     711                                carry_set_0.CarryDequeueEnqueue(3,13);
     712                        }
     713                        check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS,lex.LAngle),carry_set_0.BitBlock_inclusive_span(simd_or(ctCDPI_Callouts.Ct_starts,ctCDPI_Callouts.PI_starts),simd_or(ctCDPI_Callouts.Ct_ends,ctCDPI_Callouts.PI_ends),carry_set_0.GetCarry(16),16)),CtCDPI_starts),EOF_mask);
     714                        marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
     715                        marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
     716                        marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
     717                        carry_set_0.CarryAdjust(17);
     718                }
     719               
     720                void do_final_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams,BitBlock & EOF_mask)
     721                {
     722                        ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
     723                        ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
     724                        ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
     725                        ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
     726                        ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
     727                        ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
     728                        ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
     729                        ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
     730                        BitBlock CtCDPI_starts = simd<1>::constant<0>();
     731                        BitBlock CtCDPI_ends = simd<1>::constant<0>();
     732                        BitBlock ctCDPI_mask = simd<1>::constant<0>();
     733                        BitBlock v = simd_or(lex.LAngle,lex.Hyphen);
     734                        BitBlock w = simd_or(lex.Hyphen,lex.QMark);
     735                        BitBlock v1 = carry_set_0.BitBlock_advance_n_<1>(v,carry_set_0.Pending64(0),0);
     736                        BitBlock w1 = carry_set_0.BitBlock_advance_n_<1>(w,carry_set_0.Pending64(1),1);
     737                        BitBlock LAngle_scope = simd_andc(v1,w1);
     738                        BitBlock PI_opener = simd_and(LAngle_scope,lex.QMark);
     739                        BitBlock CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
     740                        BitBlock CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
     741                        BitBlock CD_closer = simd<1>::constant<0>();
     742                        BitBlock DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
     743                        if (bitblock::any(simd_or(lex.RBracket,carry_set_0.CarryRange(0,2))))
     744                        {
     745                                BitBlock DoubleRBracket = simd_and(carry_set_0.BitBlock_advance_ci_co(lex.RBracket,carry_set_0.GetCarry(0),0),lex.RBracket);
     746                                CD_closer = simd_and(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket,carry_set_0.GetCarry(1),1),lex.RAngle);
    784747                        }
    785748                        else
    786749                        {
    787                                 carry_set_0.CarryDequeueEnqueue(8,1);
    788                         }
    789                         if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.CarryRange(9,5))))
    790                         {
    791                                 ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
    792                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor,carry_set_0.GetCarry(9),9);
    793                                 BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    794                                 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);
    795                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_scanthru_ci_co(Ct_Cursor,simd_andc(EOF_mask,DoubleHyphen),carry_set_0.GetCarry(12),12),carry_set_0.GetCarry(13),13);
    796                                 if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    797                                 {
    798                                         assert_0_error("Error in comment syntax",simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)));
    799                                 }
    800                                 ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
    801                                 CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
    802                         }
    803                         else
    804                         {
    805                                 carry_set_0.CarryDequeueEnqueue(9,5);
    806                         }
    807                         CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
    808                         ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts,CtCDPI_ends,carry_set_0.GetCarry(14),14);
    809                         if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
    810                         {
    811                                 assert_0_error("Error in comment, CDATA or processing instruction syntax",simd_andc(ctCDPI_mask,EOF_mask));
    812                         }
    813                         CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),carry_set_0.GetCarry(15),15);
    814                         while (bitblock::any(simd_and(CtCDPI_Cursor,EOF_mask)))
    815                         {
    816                                 CarryDeclare(carry_set_1,13,0);
     750                                carry_set_0.CarryDequeueEnqueue(0,2);
     751                        }
     752                        BitBlock PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
     753                        BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener,carry_set_0.GetCarry(2),2);
     754                        if (bitblock::any(simd_or(simd_and(CtCDPI_Cursor,EOF_mask),carry_set_0.CarryRange(3,13))))
     755                        {
    817756                                CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
    818757                                BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    819                                 BitBlock CD_Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor,PI_Cursor),simd<1>::constant<0>(),0);
     758                                BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.GetCarry(3),3);
    820759                                BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
    821760                                BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    822                                 if (bitblock::any(PI_Cursor))
     761                                if (bitblock::any(simd_or(PI_Cursor,carry_set_0.CarryRange(4,4))))
    823762                                {
    824763                                        ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
    825                                         PI_Cursor = carry_set_1.BitBlock_advance_ci_co(PI_Cursor,simd<1>::constant<0>(),1);
     764                                        PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor,carry_set_0.GetCarry(4),4);
    826765                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    827                                         BitBlock PI_name_end = carry_set_1.BitBlock_scanthru_ci_co(PI_Cursor,lex.NameScan,simd<1>::constant<0>(),2);
     766                                        BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor,lex.NameScan,carry_set_0.GetCarry(5),5);
    828767                                        BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
    829768                                        BitBlock PI_noWS = simd_andc(PI_name_end,lex.WS);
    830                                         PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(carry_set_1.BitBlock_advance_ci_co(PI_noWS,simd<1>::constant<0>(),3),PI_closer)));
     769                                        PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(carry_set_0.BitBlock_advance_ci_co(PI_noWS,carry_set_0.GetCarry(6),6),PI_closer)));
    831770                                        if (bitblock::any(PI_error))
    832771                                        {
     
    834773                                        }
    835774                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
    836                                         PI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(PI_name_end,simd_andc(EOF_mask,PI_closer),simd<1>::constant<0>(),4);
     775                                        PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end,simd_andc(EOF_mask,PI_closer),carry_set_0.GetCarry(7),7);
    837776                                        ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    838777                                        CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
    839778                                }
    840                                 if (bitblock::any(CD_Cursor))
     779                                else
     780                                {
     781                                        carry_set_0.CarryDequeueEnqueue(4,4);
     782                                }
     783                                if (bitblock::any(simd_or(CD_Cursor,carry_set_0.CarryRange(8,1))))
    841784                                {
    842785                                        ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    843                                         CD_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CD_Cursor,simd_andc(EOF_mask,CD_closer),simd<1>::constant<0>(),5);
     786                                        CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor,simd_andc(EOF_mask,CD_closer),carry_set_0.GetCarry(8),8);
    844787                                        ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    845788                                        CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
    846789                                }
    847                                 if (bitblock::any(Ct_Cursor))
     790                                else
     791                                {
     792                                        carry_set_0.CarryDequeueEnqueue(8,1);
     793                                }
     794                                if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.CarryRange(9,5))))
    848795                                {
    849796                                        ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
    850                                         Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(Ct_Cursor,simd<1>::constant<0>(),6);
     797                                        Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor,carry_set_0.GetCarry(9),9);
    851798                                        BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    852                                         Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_advance_ci_co(Ct_Cursor,simd<1>::constant<0>(),7),simd<1>::constant<0>(),8);
    853                                         Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_scanthru_ci_co(Ct_Cursor,simd_andc(EOF_mask,DoubleHyphen),simd<1>::constant<0>(),9),simd<1>::constant<0>(),10);
     799                                        Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_advance_ci_co(Ct_Cursor,carry_set_0.GetCarry(10),10),carry_set_0.GetCarry(11),11);
     800                                        Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_scanthru_ci_co(Ct_Cursor,simd_andc(EOF_mask,DoubleHyphen),carry_set_0.GetCarry(12),12),carry_set_0.GetCarry(13),13);
    854801                                        if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    855802                                        {
     
    859806                                        CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
    860807                                }
     808                                else
     809                                {
     810                                        carry_set_0.CarryDequeueEnqueue(9,5);
     811                                }
    861812                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
    862                                 ctCDPI_mask = carry_set_1.BitBlock_inclusive_span(CtCDPI_starts,CtCDPI_ends,simd<1>::constant<0>(),11);
     813                                ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts,CtCDPI_ends,carry_set_0.GetCarry(14),14);
    863814                                if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
    864815                                {
    865816                                        assert_0_error("Error in comment, CDATA or processing instruction syntax",simd_andc(ctCDPI_mask,EOF_mask));
    866817                                }
    867                                 CtCDPI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),simd<1>::constant<0>(),12);
    868                                 LocalCarryCombine(carry_set_0,carry_set_1,3,13);
    869                         }
    870                 }
    871                 else
    872                 {
    873                         carry_set_0.CarryDequeueEnqueue(3,13);
    874                 }
    875                 check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS,lex.LAngle),carry_set_0.BitBlock_inclusive_span(simd_or(ctCDPI_Callouts.Ct_starts,ctCDPI_Callouts.PI_starts),simd_or(ctCDPI_Callouts.Ct_ends,ctCDPI_Callouts.PI_ends),carry_set_0.GetCarry(16),16)),CtCDPI_starts),EOF_mask);
    876                 marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
    877                 marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
    878                 marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
    879         }
    880        
    881         CarryDeclare(carry_set_0,17,2);
    882 };
    883  
     818                                CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),carry_set_0.GetCarry(15),15);
     819                                while (bitblock::any(simd_and(CtCDPI_Cursor,EOF_mask)))
     820                                {
     821                                        CarryDeclare(carry_set_1,13,0);
     822                                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
     823                                        BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
     824                                        BitBlock CD_Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor,PI_Cursor),simd<1>::constant<0>(),0);
     825                                        BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
     826                                        BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
     827                                        if (bitblock::any(PI_Cursor))
     828                                        {
     829                                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
     830                                                PI_Cursor = carry_set_1.BitBlock_advance_ci_co(PI_Cursor,simd<1>::constant<0>(),1);
     831                                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
     832                                                BitBlock PI_name_end = carry_set_1.BitBlock_scanthru_ci_co(PI_Cursor,lex.NameScan,simd<1>::constant<0>(),2);
     833                                                BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
     834                                                BitBlock PI_noWS = simd_andc(PI_name_end,lex.WS);
     835                                                PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(carry_set_1.BitBlock_advance_ci_co(PI_noWS,simd<1>::constant<0>(),3),PI_closer)));
     836                                                if (bitblock::any(PI_error))
     837                                                {
     838                                                        assert_0_error("Error in PI syntax",PI_error);
     839                                                }
     840                                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
     841                                                PI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(PI_name_end,simd_andc(EOF_mask,PI_closer),simd<1>::constant<0>(),4);
     842                                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
     843                                                CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     844                                        }
     845                                        if (bitblock::any(CD_Cursor))
     846                                        {
     847                                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
     848                                                CD_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CD_Cursor,simd_andc(EOF_mask,CD_closer),simd<1>::constant<0>(),5);
     849                                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
     850                                                CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     851                                        }
     852                                        if (bitblock::any(Ct_Cursor))
     853                                        {
     854                                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
     855                                                Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(Ct_Cursor,simd<1>::constant<0>(),6);
     856                                                BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
     857                                                Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_advance_ci_co(Ct_Cursor,simd<1>::constant<0>(),7),simd<1>::constant<0>(),8);
     858                                                Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_scanthru_ci_co(Ct_Cursor,simd_andc(EOF_mask,DoubleHyphen),simd<1>::constant<0>(),9),simd<1>::constant<0>(),10);
     859                                                if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
     860                                                {
     861                                                        assert_0_error("Error in comment syntax",simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)));
     862                                                }
     863                                                ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
     864                                                CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
     865                                        }
     866                                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
     867                                        ctCDPI_mask = carry_set_1.BitBlock_inclusive_span(CtCDPI_starts,CtCDPI_ends,simd<1>::constant<0>(),11);
     868                                        if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
     869                                        {
     870                                                assert_0_error("Error in comment, CDATA or processing instruction syntax",simd_andc(ctCDPI_mask,EOF_mask));
     871                                        }
     872                                        CtCDPI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),simd<1>::constant<0>(),12);
     873                                        LocalCarryCombine(carry_set_0,carry_set_1,3,13);
     874                                }
     875                        }
     876                        else
     877                        {
     878                                carry_set_0.CarryDequeueEnqueue(3,13);
     879                        }
     880                        check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS,lex.LAngle),carry_set_0.BitBlock_inclusive_span(simd_or(ctCDPI_Callouts.Ct_starts,ctCDPI_Callouts.PI_starts),simd_or(ctCDPI_Callouts.Ct_ends,ctCDPI_Callouts.PI_ends),carry_set_0.GetCarry(16),16)),CtCDPI_starts),EOF_mask);
     881                        marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
     882                        marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
     883                        marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
     884                }
     885               
     886                CarryDeclare(carry_set_0,17,2);
     887        };
     888         
    884889struct Parse_tags
    885890{
    886891        Parse_tags()
    887         {}
     892        {
     893        }
     894         
    888895        IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct Tag_Callouts & tag_Callouts)
    889896        {
     
    11551162{
    11561163        Parse_refs()
    1157         {}
     1164        {
     1165        }
     1166         
    11581167        IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct Ref_Callouts & ref_Callouts)
    11591168        {
     
    12351244{
    12361245        Validate_xml_names()
    1237         {}
     1246        {
     1247        }
     1248         
    12381249        IDISA_INLINE void do_block(struct CtCDPI_Callouts & ctCDPI_Callouts,struct Ref_Callouts & ref_Callouts,struct Tag_Callouts & tag_Callouts,struct Lex & lex,struct U8 & u8,struct Check_streams & check_streams)
    12391250        {
     
    12931304{
    12941305        Do_check_streams()
    1295         {}
     1306        {
     1307        }
     1308         
    12961309        IDISA_INLINE void do_block(struct Marker & marker,struct Tag_Callouts & tag_Callouts,struct Check_streams & check_streams)
    12971310        {
Note: See TracChangeset for help on using the changeset viewer.