Changeset 3260


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

Added PabloB state node and state parameters to Kernels.

Location:
proto/pabloj/trunk
Files:
1 added
2 deleted
9 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        {
  • proto/pabloj/trunk/src/application/generators/ApplicationGenerator.java

    r3249 r3260  
    5555               
    5656                // Transformation configurations to support multiple backends
    57                 toolchain.pabloS.lang.BuiltinEncoder pabloSbuiltins2Lang  = null;
    58                 toolchain.pabloB.lang.BuiltinEncoder pabloBBuiltins2Lang  = null;
    59                 AbstractUnparser unparser                       = null;
     57                toolchain.pabloS.lang.BuiltinEncoder pabloSbuiltinsEncoder  = null;
     58                toolchain.pabloB.lang.BuiltinEncoder pabloBBuiltinsEncoder  = null;
     59                AbstractUnparser unparser                                                                       = null;
    6060               
    61                 toolchain.pabloB.lang.carrySet.CarrySetEncoder carrySet2Lang = null;
     61                toolchain.pabloB.lang.carrySet.CarrySetEncoder carrySetEncoder = null;
    6262                               
    6363                if(applicationConfiguration.targetLang.contentEquals(Configuration.CLANG)) {
    64             pabloSbuiltins2Lang = new toolchain.pabloS.lang.PabloSBuiltins2C();
    65             pabloBBuiltins2Lang = new toolchain.pabloB.lang.PabloBBuiltins2C();
    66             carrySet2Lang = new toolchain.pabloB.lang.carrySet.CarrySetBuiltins2C();
    67                         unparser      = new Unparser(new IDISABuiltin2C());                     
     64            pabloSbuiltinsEncoder       = new toolchain.pabloS.lang.PabloSBuiltins2C();
     65            pabloBBuiltinsEncoder       = new toolchain.pabloB.lang.PabloBBuiltins2C();
     66            carrySetEncoder             = new toolchain.pabloB.lang.carrySet.CarrySetBuiltins2C();
     67                        unparser                        = new Unparser(new IDISABuiltin2C());                   
    6868                } else if(applicationConfiguration.targetLang.contentEquals(Configuration.CPPLANG)) {
    69                         pabloSbuiltins2Lang = new toolchain.pabloS.lang.PabloSBuiltins2CPP();
    70                         pabloBBuiltins2Lang = new toolchain.pabloB.lang.PabloBBuiltins2CPP();
    71                         carrySet2Lang = new toolchain.pabloB.lang.carrySet.CarrySetBuiltins2CPP();
    72                         unparser          = new Unparser(new IDISABuiltin2CPP());
     69                        pabloSbuiltinsEncoder   = new toolchain.pabloS.lang.PabloSBuiltins2CPP();
     70                        pabloBBuiltinsEncoder   = new toolchain.pabloB.lang.PabloBBuiltins2CPP();
     71                        carrySetEncoder                 = new toolchain.pabloB.lang.carrySet.CarrySetBuiltins2CPP();
     72                        unparser                                = new Unparser(new IDISABuiltin2CPP());
    7373                } /*else if(applicationConfiguration.targetLang.contentEquals(Configuration.LLVM)) {  // default C++
    7474                        builtins2Lang = new PabloSBuiltins2CPP();
     
    8585                        // transform PabloS builtins to Carry Set builtins
    8686                        toolchain.pabloS.transformer.Transformer pabloSXFormer = new toolchain.pabloS.transformer.Transformer(pabloSAST);
    87                         pabloSXFormer.setBuiltins2Lang(pabloSbuiltins2Lang);
    88                         pabloSXFormer.setCarrySet2Lang(carrySet2Lang);
     87                        pabloSXFormer.setBuiltins2Lang(pabloSbuiltinsEncoder);
     88                        pabloSXFormer.setCarrySet2Lang(carrySetEncoder);
    8989                       
    9090                        // Transform PabloS global functions in non-final block mode
     
    9696                        pabloS.ast.ProgramNode optDecoratedTree = (pabloS.ast.ProgramNode)pabloSXFormer.xForm();
    9797
    98                         // Transform PabloS to PabloB
    99                        
    100 
    101                         // 1. List stream functions
    102                         // 2. Map
    103                        
    10498                        ArrayList<pabloS.ast.FuncDefNode> funcDefNodes = StreamFunctions.makeList(pabloSAST);
    10599                        Map<String, CarryInfoSet> carryInfoSetMap = CarryInfoSetFactory.makeCarryInfoSetMap(funcDefNodes); 
    106100                       
    107                         PabloS2PabloBXFormer pabloS2PabloBXFormer = new PabloS2PabloBXFormer(carryInfoSetMap, carrySet2Lang);
     101                        PabloS2PabloBXFormer pabloS2PabloBXFormer = new PabloS2PabloBXFormer(carryInfoSetMap, carrySetEncoder);
    108102                        pabloBAST = pabloS2PabloBXFormer.XForm(decoratedTree, optDecoratedTree);
    109103                       
     
    117111        // PabloB AST Transforms
    118112        toolchain.pabloB.transformer.Transformer pabloBXFormer = new toolchain.pabloB.transformer.Transformer(pabloBAST);
    119         pabloBXFormer.setBuiltins2Lang(pabloBBuiltins2Lang);
     113        pabloBXFormer.setBuiltins2Lang(pabloBBuiltinsEncoder);
    120114       
    121115        if(applicationConfiguration.addAssertBitBlockAlignStmts) {
  • proto/pabloj/trunk/src/pabloS/ast/ASTNode.java

    r3259 r3260  
    2525       
    2626        Token token;
    27         int productionTag;
     27        int productionTag = NO_TAG;
    2828        boolean simplifiable;
     29        boolean compressed = false;
    2930       
    3031        private Type type = null;
     
    8283                return productionTag;
    8384        }
    84        
     85        public void setCompressed() {
     86                compressed = true;
     87        }
     88        public boolean isCompressed() {
     89                return compressed;
     90        }
    8591        public void setSimplifiable(boolean value) {
    8692                simplifiable = value;
  • proto/pabloj/trunk/src/pabloS/parser/Parser.java

    r3259 r3260  
    13461346        // return node or, if it has one child, its single child.       
    13471347        private ASTNode compressIfPossible(ASTNode node) {
    1348                 return node.nChildren() == 1 ? node.child(0) : node;
     1348                if(node.nChildren() != 1) {
     1349                        return node;
     1350                }
     1351                ASTNode result = node.child(0);
     1352                result.setCompressed();
     1353                return result;
    13491354        }
    13501355       
     
    13581363                ASTNode left   = top.child(0);
    13591364                ASTNode newTop = top.child(1);
    1360                 if((newTop.nChildren() != 2) || !fromSameProduction(top, newTop)) {
     1365               
     1366                if( (newTop.nChildren() == 2)  &&  fromSameProduction(top, newTop) ) {
     1367                        ASTNode middle = newTop.child(0);
     1368                        ASTNode right = newTop.child(1);
     1369
     1370                        top.initChildren();
     1371                        top.appendChild(left);
     1372                        top.appendChild(middle);
     1373                        top = rotateLeftIfPossible(top);
     1374
     1375                        newTop.initChildren();
     1376                        newTop.appendChild(top);
     1377                        newTop.appendChild(right);
     1378
     1379                        return newTop;
     1380                }
     1381                else  {
    13611382                        return top;
    13621383                }
    1363                 ASTNode middle = newTop.child(0);
    1364                 ASTNode right = newTop.child(1);
    1365                
    1366                 top.initChildren();
    1367                 top.appendChild(left);
    1368                 top.appendChild(middle);
    1369                 top = rotateLeftIfPossible(top);
    1370                
    1371                 newTop.initChildren();
    1372                 newTop.appendChild(top);
    1373                 newTop.appendChild(right);
    1374                
    1375                 return newTop;
    13761384        }
    13771385        private boolean fromSameProduction(ASTNode node1, ASTNode node2) {
    1378                 return node1.getProductionTag() == node2.getProductionTag();
     1386                return (node1.getProductionTag() == node2.getProductionTag()) &&
     1387                           !node1.isCompressed() &&
     1388                           !node2.isCompressed();
    13791389        }
    13801390        private ASTNode promoteLastChild(ASTNode tree) {
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Generators.java

    r3257 r3260  
    44
    55package toolchain.pabloB.ast;
     6import java.util.ArrayList;
    67import java.util.List;
    78
     
    138139       
    139140        // stateParameter      ->  stateName ASSIGN stateValue TERMINATOR ;
    140         public static StateParameterNode makeStateParameterNode (IdentifierNode identifier, StateValueNode stateValue) {
    141             StateParameterNode stateParameter = new StateParameterNode(identifier.getToken());
    142             stateParameter.appendChild(identifier);
     141        public static StateParameterNode makeStateParameterNode (IdentifierNode stateName, StateValueNode stateValue) {
     142            StateParameterNode stateParameter = new StateParameterNode(stateName.getToken());
     143            stateParameter.appendChild(stateName);
    143144            stateParameter.appendChild(stateValue);
    144145            return stateParameter;
     
    154155            return stateValue;
    155156        }
     157       
     158        // stateValue helper
     159        public static StateValueNode makeStateValueNode(Integer value, Locator locator) {
     160                List<Integer> values = new ArrayList<Integer>();
     161                values.add(value);
     162                return Generators.makeStateValueNode(values, locator);
     163        }       
    156164       
    157165        /* TODO Update init section and refactor
  • proto/pabloj/trunk/src/toolchain/pabloB/codeGenerator/visitors/Unparser.java

    r3258 r3260  
    4747
    4848public class Unparser extends AbstractUnparser {
    49 
    50         private String stateIdentifier = null;
    5149       
    5250        //////////////////////////////////////////////////////////////
     
    9290               
    9391
    94 //              CodeStore initDef = childResults.get(1); // KH: breakage
     92                CodeStore initDef = childResults.get(1); // KH: breakage
    9593               
    9694                CodeStore funcDefCodeStore = childResults.get(2);
     
    10098               
    10199                code.indentedFormattedLine("%s()", kernelName);
    102                
    103                 code.addLine("{}");
    104 //              code.addAll(initDef, 0); // KH: breakage
     100                code.addAll(initDef, 0);
    105101               
    106102                funcDefCodeStore.prependToFirst("IDISA_INLINE ");
    107                
    108103                code.addAll(funcDefCodeStore, 0);
    109104               
     
    132127        // Kernel Initialization
    133128        ////////////////////////////////////////////////////////////////////////////
    134 /*     
     129
    135130        public CodeStore visitLeave(StateDefNode node, List<CodeStore> childResults) {
    136131                CodeStore code = new CodeStore();
    137132               
    138                 // add strings // visit enter is needed here
    139                
    140                 CodeStore initBlockCodeStore = childResults.get(0);
    141                
    142133                code.addLine("{");
    143                 code.addAll(initBlockCodeStore, 1);
    144                 code.dedentedLine("}");         
     134                for (CodeStore child: childResults) {
     135                        code.addAll(child, 1);
     136                }       
     137                code.addLine("}");                             
    145138               
    146139                code.addLine(" "); // a blank line
     
    148141                return code;
    149142        }
    150                 */
    151 
     143
     144        public CodeStore visitLeave(StateParameterNode node, List<CodeStore> childResults) {
     145                CodeStore code = new CodeStore();               
     146                return code;
     147        }
     148
     149        public CodeStore visitLeave(StateValueNode node, List<CodeStore> childResults) {
     150                CodeStore code = new CodeStore();               
     151                return code;
     152        }
     153
     154       
    152155/*      public CodeStore visitLeave(InitBlockNode node, List<CodeStore> childResults) {
    153156                CodeStore code = new CodeStore();
     
    499502                return code;
    500503        }
     504
    501505}
  • proto/pabloj/trunk/src/toolchain/pabloB/lang/PabloBBuiltin.java

    r3208 r3260  
    88  public enum PabloBBuiltin {
    99
    10       PRINT_BITBLOCK("PrintBitBlock",CarryType.None, 1),
    11       ASSERT_BITBLOCK_ALIGN("AssertBitBlockAlign",CarryType.None, 1);
     10      PRINT_BITBLOCK("PrintBitBlock", CarryType.None, 1),
     11      ASSERT_BITBLOCK_ALIGN("AssertBitBlockAlign", CarryType.None, 1);
    1212     
    1313      public enum CarryType{One, N, None};   
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/PabloS2PabloBXFormer.java

    r3257 r3260  
    88
    99import java.lang.reflect.Constructor;
    10 import java.util.HashMap;
    11 import java.util.List;
    12 import java.util.Map;
    13 
    14 import pabloB.ast.FuncCallNode;
    15 import pabloB.ast.StateParameterNode;
     10import java.util.*;
     11
     12import pabloB.ast.*;
     13import pabloB.inputHandler.Locator;
     14import toolchain.pabloB.ast.Accessors;
     15import toolchain.pabloB.ast.Generators;
    1616import pabloS.ast.ASTVisitor.Default;
    1717import pabloS.lexicalAnalyzer.Lextant;
    18 import toolchain.pabloB.ast.Generators;
     18
     19import toolchain.pabloB.lang.KernelState;
     20import toolchain.pabloB.lang.carrySet.CarrySetBuiltins;
    1921import toolchain.pabloB.lang.carrySet.CarrySetEncoder;
    20 import toolchain.pabloB.lang.carrySet.CarrySetBuiltins;
    21 import toolchain.pabloS.ast.Accessors;
    2222import toolchain.pabloS.lang.BuiltinCallUtil;
    2323import toolchain.pabloS.transformer.visitors.carry.CarryInfoSet;
     
    2828        private static final String DO_OPT_BLOCK        = "do_final_block";
    2929       
    30         public static Boolean PABLO2PABLOB_XFORM_SUPPORT = false;
    31         public static String PABLO2PABLOB_XFORM_SUPPORT_MSG = "PabloS to PabloB node transformation not supported.";
     30        public static Boolean   PABLO2PABLOB_XFORM_SUPPORT = false;
     31        public static String    PABLO2PABLOB_XFORM_SUPPORT_MSG = "PabloS to PabloB node transformation not supported.";
    3232       
    3333        private pabloS.ast.ASTNode decoratedASTTree;   
     
    5151                pabloB.ast.ASTNode bASTTree     = this.decoratedASTTree.accept(new pabloBASTBuilder());
    5252                pabloB.ast.ASTNode bOptASTTree  = this.optDecoratedASTTree.accept(new pabloBASTBuilder());
    53                
    54                 // map function names to function definition nodes             
     53                               
    5554                Map<String, pabloB.ast.FuncDefNode> map         = makeFuncDefMap(bASTTree);
    5655                Map<String, pabloB.ast.FuncDefNode> optMap      = makeFuncDefMap(bOptASTTree);
     
    6160                        pabloB.ast.FuncDefNode optFuncDefNode           = optMap.get(entry.getKey());
    6261                       
    63                         pabloB.ast.IdentifierNode doBlockIdentifier = Generators.makeIdentifierNode(DO_BLOCK, funcDefNode);
    64                         funcDefNode.replaceChild(funcDefNode.child(1), doBlockIdentifier);
    65 
    66                         pabloB.ast.IdentifierNode doOptBlockIdentifier = Generators.makeIdentifierNode(DO_OPT_BLOCK, optFuncDefNode);
    67                         optFuncDefNode.replaceChild(optFuncDefNode.child(1), doOptBlockIdentifier);                     
     62                        Locator locator = funcDefNode.getToken();
     63                       
     64                        IdentifierNode doBlockIdentifier = Generators.makeIdentifierNode(DO_BLOCK, locator);
     65                        funcDefNode.replaceChild(Accessors.funcIdentifier(funcDefNode), doBlockIdentifier);
     66
     67                        IdentifierNode doOptBlockIdentifier = Generators.makeIdentifierNode(DO_OPT_BLOCK, locator);
     68                        optFuncDefNode.replaceChild(Accessors.funcIdentifier(optFuncDefNode), doOptBlockIdentifier);                   
    6869                       
    6970                        String kernelName = entry.getKey();                     
    70                         CarryInfoSet carryInfoSetSymbol = (CarryInfoSet) carryInfoSetMap.get(kernelName);
    71                        
    72                         pabloB.ast.StateDefNode stateDefNode = Generators.makeStateDefNode(funcDefNode);                       
    73                        
    74                         // Temporary fix
    75 /*                                             
    76             if(carryInfoSetSymbol.getCarry1Count() > 0) {
    77                                 StateInitStmtNode carry1StateNode = Generators.makeStateInitStmtNode(CarryInfoSet.CARRY1STATENAME,
    78                                                                                                                 carryInfoSetSymbol.getCarry1Array(),
    79                                                                                                                 locationToken);                 
    80                                
    81                                 IdentifierNode stateName    = makeIdentifierNode();
    82                                 StateValueNode stateValue   = makeStateValueNode();
    83                                
    84                                 // StateParameterNode stateParameter =
    85                         }
    86            
    87 */                     
    88                         /*
    89                         if(carryInfoSetSymbol.getCarryNCount() > 0) {
    90                                 StateInitStmtNode carryNStateNode = Generators.makeStateInitStmtNode(CarryInfoSet.CARRYNSTATENAME,
    91                                                                                                                 carryInfoSetSymbol.getCarryNArray(),
    92                                                                                                                 locationToken);
    93 
    94                         }
    95                         */
    96                        
    97                         if(carryInfoSetSymbol.getCarry1Count() > 0) { // KH: TODO Direct to StateDefNode.
    98                                                
    99                                 Integer [] carry1Array = carryInfoSetSymbol.getCarry1Array();   
     71                        CarryInfoSet carryInfoSetSymbol = carryInfoSetMap.get(kernelName);
     72                       
     73                        ////////////////////////////////////////////////////////////
     74                        // Kernel state parameters
     75                        ////////////////////////////////////////////////////////////
     76                        StateDefNode stateDefNode = Generators.makeStateDefNode(funcDefNode);                   
     77                       
     78                        ////////////////////////////////////////////////////////////
     79                        // Carry1
     80                IdentifierNode stateName                = Generators.makeIdentifierNode(KernelState.CARRY1_LIST.name(), locator);
     81                StateValueNode stateValue               = Generators.makeStateValueNode(carryInfoSetSymbol.Carry1List(), locator);
     82                        StateParameterNode stateParameter       = Generators.makeStateParameterNode(stateName, stateValue);
     83                        stateDefNode.appendChild(stateParameter);
     84                       
     85                        ////////////////////////////////////////////////////////////
     86                        // Carry1 Count
     87                stateName       = Generators.makeIdentifierNode(KernelState.CARRY1_COUNT.name(), locator);
     88                stateValue      = Generators.makeStateValueNode(carryInfoSetSymbol.Carry1Count(), locator);
     89                        stateParameter  = Generators.makeStateParameterNode(stateName, stateValue);
     90                        stateDefNode.appendChild(stateParameter);
     91
     92                        ////////////////////////////////////////////////////////////                   
     93                        // Add CarryFlip call for variable initialization                       
     94                       
     95                        for(Integer i : carryInfoSetSymbol.Carry1List()) {
     96
     97                                if(i > 0) {
    10098                                       
    101                                 for(int i=0; i < carry1Array.length; i++) {     
     99                                        pabloB.ast.IntegerConstantNode indexNode = Generators.makeIntegerConstantNode(i+1, locator);
    102100                                       
    103                                         if(carry1Array[i] > 0) {
    104                                                        
    105                                                         pabloB.ast.IntegerConstantNode indexNode = Generators.makeIntegerConstantNode(i, funcDefNode);
    106                                                        
    107                                                         FuncCallNode getCarryFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    108                                                                                                 CarrySetEncoder.CARRYSETBASENAME,
    109                                                                                                 carrySetEncoder.getCode(CarrySetBuiltins.GETCARRY),
    110                                                                                                 funcDefNode,
    111                                                                                                 indexNode);
    112                                                
    113                                                         FuncCallNode carryFlipFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    114                                                                                                 CarrySetEncoder.CARRYSETBASENAME,
    115                                                                                                 carrySetEncoder.getCode(CarrySetBuiltins.CARRYFLIP),
    116                                                                                                 funcDefNode,
    117                                                                                                 getCarryFuncCall);
    118                                                        
    119                                                         FuncCallNode setCarryFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    120                                                                                                 CarrySetEncoder.CARRYSETBASENAME,
    121                                                                                                 carrySetEncoder.getCode(CarrySetBuiltins.SETCARRY),
    122                                                                                                 funcDefNode,
    123                                                                                                 carryFlipFuncCall, indexNode);
    124                                                                                                        
    125                                                         // ? toolchain.pabloB.ast.Accessors.initBlockNode(initDefNode).appendChild(setCarryFuncCall);
    126                                         }
     101                                        FuncCallNode getCarryFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
     102                                                                                CarrySetEncoder.CARRYSETBASENAME,
     103                                                                                carrySetEncoder.getCode(CarrySetBuiltins.GETCARRY),
     104                                                                                locator,
     105                                                                                indexNode);
     106                               
     107                                        FuncCallNode carryFlipFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
     108                                                                                CarrySetEncoder.CARRYSETBASENAME,
     109                                                                                carrySetEncoder.getCode(CarrySetBuiltins.CARRYFLIP),
     110                                                                                locator,
     111                                                                                getCarryFuncCall);
     112                                       
     113                                        FuncCallNode setCarryFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
     114                                                                                CarrySetEncoder.CARRYSETBASENAME,
     115                                                                                carrySetEncoder.getCode(CarrySetBuiltins.SETCARRY),
     116                                                                                locator,
     117                                                                                carryFlipFuncCall, indexNode);
     118                                                                                       
     119                                        stateDefNode.appendChild(setCarryFuncCall);
    127120                                }
    128121                        }
    129122                       
    130                         // make kernel node
     123                       
     124                        ////////////////////////////////////////////////////////////
     125                        // CarryN
     126                stateName       = Generators.makeIdentifierNode(KernelState.CARRYN_LIST.name(), locator);
     127                stateValue      = Generators.makeStateValueNode(carryInfoSetSymbol.CarryNList(), locator);
     128                        stateParameter  = Generators.makeStateParameterNode(stateName, stateValue);
     129                        stateDefNode.appendChild(stateParameter);
     130
     131                        ////////////////////////////////////////////////////////////
     132                        // CarryN Count                 
     133                stateName       = Generators.makeIdentifierNode(KernelState.CARRYN_COUNT.name(), locator);
     134                stateValue      = Generators.makeStateValueNode(carryInfoSetSymbol.CarryNCount(), locator);
     135                        stateParameter  = Generators.makeStateParameterNode(stateName, stateValue);
     136                        stateDefNode.appendChild(stateParameter);
     137                       
     138                        ////////////////////////////////////////////////////////////
     139                        // KH: TODO - LookAhead
     140                stateName       = Generators.makeIdentifierNode(KernelState.LOOK_AHEAD.name(), locator);
     141                stateValue      = Generators.makeStateValueNode(0, locator);
     142                        stateParameter  = Generators.makeStateParameterNode(stateName, stateValue);
     143                        stateDefNode.appendChild(stateParameter);
     144                       
     145                        ////////////////////////////////////////////////////////////
     146                        // KH: TODO - LookBehind
     147                stateName       = Generators.makeIdentifierNode(KernelState.LOOK_BEHIND.name(), locator);
     148                stateValue      = Generators.makeStateValueNode(0, locator);
     149                        stateParameter  = Generators.makeStateParameterNode(stateName, stateValue);
     150                        stateDefNode.appendChild(stateParameter);
     151                       
    131152                        pabloB.ast.KernelDefNode kernelDefNode =
    132153                                        Generators.makeKernelDef(kernelName,
     
    136157                                                        funcDefNode.getToken());
    137158                       
    138                         // add carry declare - hack
     159                        // add CarryDeclare(...) - hack
    139160                        Generators.addFuncCallNode(kernelDefNode, (pabloB.ast.FuncCallNode) funcDefNode.lastChild());
    140161                       
    141162                        // splice kernel node onto PabloB tree
    142163                        funcDefNode.updateSelf(kernelDefNode);
    143                 }
     164
     165                        }
    144166               
    145167                return bASTTree;
     
    200222                // Translates PabloS stream type to PabloB bitblock type 
    201223                //
    202                 // KH: TODO handle field width attributes on PabloS stream types
     224                // KH: TODO - Handle field width attributes on PabloS stream types
    203225                //
    204226                ////////////////////////////////////////////////////////////////////////////////////
     
    234256                                // field width integer constant
    235257                                int fieldWidthValue
    236                                         = Integer.valueOf(Accessors.argument(node, 0).getToken().getLexeme());
     258                                        = Integer.valueOf(toolchain.pabloS.ast.Accessors.argument(node, 0).getToken().getLexeme());
    237259                               
    238260                                pabloS.tokens.IntConstantToken fieldWidthConstantToken
     
    249271                                // mask integer constant
    250272                                int maskValue
    251                                         = Integer.valueOf(Accessors.argument(node, 1).getToken().getLexeme());
     273                                        = Integer.valueOf(toolchain.pabloS.ast.Accessors.argument(node, 1).getToken().getLexeme());
    252274                               
    253275                                pabloS.tokens.IntConstantToken maskToken
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/CarryInfoSet.java

    r3249 r3260  
    1818        }
    1919       
    20         public int getCarry1Count() {
     20        public int Carry1Count() {
    2121                return carry1.size();
    2222        }
    2323
    24         public int getCarryNCount() {
     24        public int CarryNCount() {
    2525                return carryN.size();
    2626        }       
     
    3434        }       
    3535
    36         public Integer [] getCarry1Array() {
    37                 return (Integer [])carry1.toArray(new Integer [carry1.size()]);
     36        public ArrayList<Integer> Carry1List() {
     37                return carry1;
    3838        }
    3939
    40         public Integer [] getCarryNArray() {
    41                 return (Integer [])carryN.toArray(new Integer [carryN.size()]);
     40        public ArrayList<Integer> CarryNList() {
     41                return carryN;
    4242        }
    4343
Note: See TracChangeset for help on using the changeset viewer.