Changeset 3376


Ignore:
Timestamp:
Jun 28, 2013, 5:39:27 PM (6 years ago)
Author:
ksherdy
Message:

Partial check-in, may revert.

Location:
proto/pabloj/trunk
Files:
4 edited
1 moved

Legend:

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

    r3351 r3376  
    387387                        u8.badprefix = simd_or(temp68,temp71);
    388388                        u8_error = u8.badprefix;
    389                         carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix2,carry_set_0.getCarry(0),u8.scope22));
     389                        u8.scope22 = pablo.Advance(u8.prefix2);
    390390                        u8anyscope = u8.scope22;
    391                         if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.carryRange(1,9))))
     391                        if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.carryRange(0,9))))
    392392                        {
    393393                                BitBlock xE0;
     
    411411                                u8.xBF = simd_and(temp73,temp23);
    412412                                u8.xBE = simd_and(temp73,temp15);
    413                                 carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix3,carry_set_0.getCarry(1),u8.scope32));
    414                                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(u8.scope32,carry_set_0.getCarry(2),u8.scope33));
    415                                 carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix4,carry_set_0.getCarry(3),u8.scope42));
    416                                 carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(u8.scope42,carry_set_0.getCarry(4),u8.scope43));
    417                                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(u8.scope43,carry_set_0.getCarry(5),u8.scope44));
     413                                u8.scope32 = pablo.Advance(u8.prefix3);
     414                                u8.scope33 = pablo.Advance(u8.scope32);
     415                                u8.scope42 = pablo.Advance(u8.prefix4);
     416                                u8.scope43 = pablo.Advance(u8.scope42);
     417                                u8.scope44 = pablo.Advance(u8.scope43);
    418418                                BitBlock E0_F0_scope;
    419                                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(simd_or(xE0,xF0),carry_set_0.getCarry(6),E0_F0_scope));
     419                                E0_F0_scope = pablo.Advance(simd_or(xE0,xF0));
    420420                                BitBlock ED_F4_scope;
    421                                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(simd_or(xED,xF4),carry_set_0.getCarry(7),ED_F4_scope));
     421                                ED_F4_scope = pablo.Advance(simd_or(xED,xF4));
    422422                                u8.xE0_scope = simd_and(u8.scope32,E0_F0_scope);
    423423                                u8.xED_scope = simd_and(u8.scope32,ED_F4_scope);
    424424                                u8.xF0_scope = simd_and(u8.scope42,E0_F0_scope);
    425425                                u8.xF4_scope = simd_and(u8.scope42,ED_F4_scope);
    426                                 carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(xEF,carry_set_0.getCarry(8),u8.xEF_scope));
     426                                u8.xEF_scope = pablo.Advance(xEF);
    427427                                BitBlock u8lastscope;
    428428                                u8lastscope = simd_or(simd_or(u8.scope22,u8.scope33),u8.scope44);
     
    438438                                u8_error = simd_or(u8_error,simd_or(simd_or(simd_or(u8error1,u8error2),u8error3),u8error4));
    439439                                BitBlock EF_BF_pending;
    440                                 carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(simd_and(u8.xEF_scope,u8.xBF),carry_set_0.getCarry(9),EF_BF_pending));
     440                                EF_BF_pending = pablo.Advance(simd_and(u8.xEF_scope,u8.xBF));
    441441                                u8_FFFE_FFFF = simd_and(EF_BF_pending,simd_or(u8.xBE,u8.xBF));
    442442                        }
    443443                        else
    444444                        {
    445                                 carry_set_0.carryDequeueEnqueue(1,9);
     445                                carry_set_0.carryDequeueEnqueue(0,9);
    446446                        }
    447447                        BitBlock u8mismatch;
     
    654654                        u8.badprefix = simd_or(temp68,temp71);
    655655                        u8_error = u8.badprefix;
    656                         carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix2,carry_set_0.getCarry(0),u8.scope22));
     656                        u8.scope22 = pablo.Advance(u8.prefix2);
    657657                        u8anyscope = u8.scope22;
    658                         if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.carryRange(1,9))))
     658                        if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.carryRange(0,9))))
    659659                        {
    660660                                BitBlock xE0;
     
    678678                                u8.xBF = simd_and(temp73,temp23);
    679679                                u8.xBE = simd_and(temp73,temp15);
    680                                 carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix3,carry_set_0.getCarry(1),u8.scope32));
    681                                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(u8.scope32,carry_set_0.getCarry(2),u8.scope33));
    682                                 carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix4,carry_set_0.getCarry(3),u8.scope42));
    683                                 carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(u8.scope42,carry_set_0.getCarry(4),u8.scope43));
    684                                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(u8.scope43,carry_set_0.getCarry(5),u8.scope44));
     680                                u8.scope32 = pablo.Advance(u8.prefix3);
     681                                u8.scope33 = pablo.Advance(u8.scope32);
     682                                u8.scope42 = pablo.Advance(u8.prefix4);
     683                                u8.scope43 = pablo.Advance(u8.scope42);
     684                                u8.scope44 = pablo.Advance(u8.scope43);
    685685                                BitBlock E0_F0_scope;
    686                                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(simd_or(xE0,xF0),carry_set_0.getCarry(6),E0_F0_scope));
     686                                E0_F0_scope = pablo.Advance(simd_or(xE0,xF0));
    687687                                BitBlock ED_F4_scope;
    688                                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(simd_or(xED,xF4),carry_set_0.getCarry(7),ED_F4_scope));
     688                                ED_F4_scope = pablo.Advance(simd_or(xED,xF4));
    689689                                u8.xE0_scope = simd_and(u8.scope32,E0_F0_scope);
    690690                                u8.xED_scope = simd_and(u8.scope32,ED_F4_scope);
    691691                                u8.xF0_scope = simd_and(u8.scope42,E0_F0_scope);
    692692                                u8.xF4_scope = simd_and(u8.scope42,ED_F4_scope);
    693                                 carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(xEF,carry_set_0.getCarry(8),u8.xEF_scope));
     693                                u8.xEF_scope = pablo.Advance(xEF);
    694694                                BitBlock u8lastscope;
    695695                                u8lastscope = simd_or(simd_or(u8.scope22,u8.scope33),u8.scope44);
     
    705705                                u8_error = simd_or(u8_error,simd_or(simd_or(simd_or(u8error1,u8error2),u8error3),u8error4));
    706706                                BitBlock EF_BF_pending;
    707                                 carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(simd_and(u8.xEF_scope,u8.xBF),carry_set_0.getCarry(9),EF_BF_pending));
     707                                EF_BF_pending = pablo.Advance(simd_and(u8.xEF_scope,u8.xBF));
    708708                                u8_FFFE_FFFF = simd_and(EF_BF_pending,simd_or(u8.xBE,u8.xBF));
    709709                        }
    710710                        else
    711711                        {
    712                                 carry_set_0.carryDequeueEnqueue(1,9);
     712                                carry_set_0.carryDequeueEnqueue(0,9);
    713713                        }
    714714                        BitBlock u8mismatch;
     
    756756                w = simd_or(lex.Hyphen,lex.QMark);
    757757                BitBlock v1;
    758                 carry_set_0.getPending64(0) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(v,carry_set_0.getPending64(0),v1));
     758                v1 = pablo.AdvanceN(v,1);
    759759                BitBlock w1;
    760                 carry_set_0.getPending64(1) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(w,carry_set_0.getPending64(1),w1));
     760                w1 = pablo.AdvanceN(w,1);
    761761                BitBlock LAngle_scope;
    762762                LAngle_scope = simd_andc(v1,w1);
     
    775775                        BitBlock DoubleRBracket;
    776776                        BitBlock _temp0;
    777                         carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(lex.RBracket,carry_set_0.getCarry(0),_temp0));
     777                        _temp0 = pablo.Advance(lex.RBracket);
    778778                        DoubleRBracket = simd_and(_temp0,lex.RBracket);
    779779                        BitBlock _temp1;
    780                         carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(DoubleRBracket,carry_set_0.getCarry(1),_temp1));
     780                        _temp1 = pablo.Advance(DoubleRBracket);
    781781                        CD_closer = simd_and(_temp1,lex.RAngle);
    782782                }
     
    788788                PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
    789789                BitBlock CtCDPI_Cursor;
    790                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanToFirst(CtCDPI_opener,carry_set_0.getCarry(2),CtCDPI_Cursor));
    791                 if (bitblock::any(simd_or(CtCDPI_Cursor,carry_set_0.carryRange(3,13))))
     790                CtCDPI_Cursor = pablo.ScanToFirst(CtCDPI_opener);
     791                if (bitblock::any(simd_or(CtCDPI_Cursor,carry_set_0.carryRange(0,13))))
    792792                {
    793793                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
     
    795795                        PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    796796                        BitBlock CD_Ct_Cursor;
    797                         carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.getCarry(3),CD_Ct_Cursor));
     797                        CD_Ct_Cursor = pablo.Advance(simd_andc(CtCDPI_Cursor,PI_Cursor));
    798798                        BitBlock CD_Cursor;
    799799                        CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
    800800                        BitBlock Ct_Cursor;
    801801                        Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    802                         if (bitblock::any(simd_or(PI_Cursor,carry_set_0.carryRange(4,4))))
     802                        if (bitblock::any(simd_or(PI_Cursor,carry_set_0.carryRange(0,4))))
    803803                        {
    804804                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
    805                                 carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_0.getCarry(4),PI_Cursor));
     805                                PI_Cursor = pablo.Advance(PI_Cursor);
    806806                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    807807                                BitBlock PI_name_end;
    808                                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_0.getCarry(5),PI_name_end));
     808                                PI_name_end = pablo.ScanThru(PI_Cursor,lex.NameScan);
    809809                                BitBlock PI_error;
    810810                                PI_error = simd_and(PI_Cursor,PI_name_end);
     
    812812                                PI_noWS = simd_andc(PI_name_end,lex.WS);
    813813                                BitBlock _temp2;
    814                                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_0.getCarry(6),_temp2));
     814                                _temp2 = pablo.Advance(PI_noWS);
    815815                                PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(_temp2,PI_closer)));
    816816                                if (bitblock::any(PI_error))
     
    819819                                }
    820820                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
    821                                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_not(PI_closer),carry_set_0.getCarry(7),PI_Cursor));
     821                                PI_Cursor = pablo.ScanTo(PI_name_end,PI_closer);
    822822                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    823823                                CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     
    825825                        else
    826826                        {
    827                                 carry_set_0.carryDequeueEnqueue(4,4);
    828                         }
    829                         if (bitblock::any(simd_or(CD_Cursor,carry_set_0.carryRange(8,1))))
     827                                carry_set_0.carryDequeueEnqueue(0,4);
     828                        }
     829                        if (bitblock::any(simd_or(CD_Cursor,carry_set_0.carryRange(0,1))))
    830830                        {
    831831                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    832                                 carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_not(CD_closer),carry_set_0.getCarry(8),CD_Cursor));
     832                                CD_Cursor = pablo.ScanTo(CD_Cursor,CD_closer);
    833833                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    834834                                CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     
    836836                        else
    837837                        {
    838                                 carry_set_0.carryDequeueEnqueue(8,1);
    839                         }
    840                         if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.carryRange(9,5))))
     838                                carry_set_0.carryDequeueEnqueue(0,1);
     839                        }
     840                        if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.carryRange(0,5))))
    841841                        {
    842842                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
    843                                 carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(9),Ct_Cursor));
     843                                Ct_Cursor = pablo.Advance(Ct_Cursor);
    844844                                BitBlock Ct_error;
    845845                                Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    846846                                BitBlock _temp3;
    847                                 carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(10),_temp3));
    848                                 carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_0.getCarry(11),Ct_Cursor));
     847                                _temp3 = pablo.Advance(Ct_Cursor);
     848                                Ct_Cursor = pablo.Advance(_temp3);
    849849                                BitBlock _temp4;
    850                                 carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_not(DoubleHyphen),carry_set_0.getCarry(12),_temp4));
    851                                 carry_set_0.getCarry(13) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_0.getCarry(13),Ct_Cursor));
     850                                _temp4 = pablo.ScanTo(Ct_Cursor,DoubleHyphen);
     851                                Ct_Cursor = pablo.Advance(_temp4);
    852852                                if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    853853                                {
     
    859859                        else
    860860                        {
    861                                 carry_set_0.carryDequeueEnqueue(9,5);
     861                                carry_set_0.carryDequeueEnqueue(0,5);
    862862                        }
    863863                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
    864                         carry_set_0.getCarry(14) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_0.getCarry(14),ctCDPI_mask));
     864                        ctCDPI_mask = pablo.InclusiveSpan(CtCDPI_starts,CtCDPI_ends);
    865865                        if (bitblock::any(simd<1>::constant<0>()))
    866866                        {
    867867                                assert_0_error(simd<1>::constant<0>(),"Error in comment, CDATA or processing instruction syntax");
    868868                        }
    869                         carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_not(CtCDPI_opener),carry_set_0.getCarry(15),CtCDPI_Cursor));
     869                        CtCDPI_Cursor = pablo.ScanTo(CtCDPI_Cursor,CtCDPI_opener);
    870870                        while (bitblock::any(CtCDPI_Cursor))
    871871                        {
     
    875875                                PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    876876                                BitBlock CD_Ct_Cursor;
    877                                 carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_1.getCarry(0),CD_Ct_Cursor));
     877                                CD_Ct_Cursor = pablo.Advance(simd_andc(CtCDPI_Cursor,PI_Cursor));
    878878                                BitBlock CD_Cursor;
    879879                                CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
     
    883883                                {
    884884                                        ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
    885                                         carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_1.getCarry(1),PI_Cursor));
     885                                        PI_Cursor = pablo.Advance(PI_Cursor);
    886886                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    887887                                        BitBlock PI_name_end;
    888                                         carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_1.getCarry(2),PI_name_end));
     888                                        PI_name_end = pablo.ScanThru(PI_Cursor,lex.NameScan);
    889889                                        BitBlock PI_error;
    890890                                        PI_error = simd_and(PI_Cursor,PI_name_end);
     
    892892                                        PI_noWS = simd_andc(PI_name_end,lex.WS);
    893893                                        BitBlock _temp2;
    894                                         carry_set_1.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_1.getCarry(3),_temp2));
     894                                        _temp2 = pablo.Advance(PI_noWS);
    895895                                        PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(_temp2,PI_closer)));
    896896                                        if (bitblock::any(PI_error))
     
    899899                                        }
    900900                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
    901                                         carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_not(PI_closer),carry_set_1.getCarry(4),PI_Cursor));
     901                                        PI_Cursor = pablo.ScanTo(PI_name_end,PI_closer);
    902902                                        ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    903903                                        CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     
    906906                                {
    907907                                        ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    908                                         carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_not(CD_closer),carry_set_1.getCarry(5),CD_Cursor));
     908                                        CD_Cursor = pablo.ScanTo(CD_Cursor,CD_closer);
    909909                                        ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    910910                                        CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     
    913913                                {
    914914                                        ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
    915                                         carry_set_1.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(6),Ct_Cursor));
     915                                        Ct_Cursor = pablo.Advance(Ct_Cursor);
    916916                                        BitBlock Ct_error;
    917917                                        Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    918918                                        BitBlock _temp3;
    919                                         carry_set_1.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(7),_temp3));
    920                                         carry_set_1.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_1.getCarry(8),Ct_Cursor));
     919                                        _temp3 = pablo.Advance(Ct_Cursor);
     920                                        Ct_Cursor = pablo.Advance(_temp3);
    921921                                        BitBlock _temp4;
    922                                         carry_set_1.getCarry(9) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_not(DoubleHyphen),carry_set_1.getCarry(9),_temp4));
    923                                         carry_set_1.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_1.getCarry(10),Ct_Cursor));
     922                                        _temp4 = pablo.ScanTo(Ct_Cursor,DoubleHyphen);
     923                                        Ct_Cursor = pablo.Advance(_temp4);
    924924                                        if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    925925                                        {
     
    930930                                }
    931931                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
    932                                 carry_set_1.getCarry(11) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_1.getCarry(11),ctCDPI_mask));
     932                                ctCDPI_mask = pablo.InclusiveSpan(CtCDPI_starts,CtCDPI_ends);
    933933                                if (bitblock::any(simd<1>::constant<0>()))
    934934                                {
    935935                                        assert_0_error(simd<1>::constant<0>(),"Error in comment, CDATA or processing instruction syntax");
    936936                                }
    937                                 carry_set_1.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_not(CtCDPI_opener),carry_set_1.getCarry(12),CtCDPI_Cursor));
    938                                 LocalCarryCombine(carry_set_0,carry_set_1,3,13);
     937                                CtCDPI_Cursor = pablo.ScanTo(CtCDPI_Cursor,CtCDPI_opener);
     938                                LocalCarryCombine(carry_set_0,carry_set_1,0,13);
    939939                        }
    940940                }
    941941                else
    942942                {
    943                         carry_set_0.carryDequeueEnqueue(3,13);
     943                        carry_set_0.carryDequeueEnqueue(0,13);
    944944                }
    945945                BitBlock _temp5;
    946                 carry_set_0.getCarry(16) = bitblock::srli<127>(pablo_blk_InclusiveSpan(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),_temp5));
     946                _temp5 = pablo.InclusiveSpan(simd_or(ctCDPI_Callouts.Ct_starts,ctCDPI_Callouts.PI_starts),simd_or(ctCDPI_Callouts.Ct_ends,ctCDPI_Callouts.PI_ends));
    947947                check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS,lex.LAngle),_temp5),CtCDPI_starts),EOF_mask);
    948948                marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
     
    973973                w = simd_or(lex.Hyphen,lex.QMark);
    974974                BitBlock v1;
    975                 carry_set_0.getPending64(0) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(v,carry_set_0.getPending64(0),v1));
     975                v1 = pablo.AdvanceN(v,1);
    976976                BitBlock w1;
    977                 carry_set_0.getPending64(1) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(w,carry_set_0.getPending64(1),w1));
     977                w1 = pablo.AdvanceN(w,1);
    978978                BitBlock LAngle_scope;
    979979                LAngle_scope = simd_andc(v1,w1);
     
    992992                        BitBlock DoubleRBracket;
    993993                        BitBlock _temp0;
    994                         carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(lex.RBracket,carry_set_0.getCarry(0),_temp0));
     994                        _temp0 = pablo.Advance(lex.RBracket);
    995995                        DoubleRBracket = simd_and(_temp0,lex.RBracket);
    996996                        BitBlock _temp1;
    997                         carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(DoubleRBracket,carry_set_0.getCarry(1),_temp1));
     997                        _temp1 = pablo.Advance(DoubleRBracket);
    998998                        CD_closer = simd_and(_temp1,lex.RAngle);
    999999                }
     
    10051005                PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
    10061006                BitBlock CtCDPI_Cursor;
    1007                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanToFirst(CtCDPI_opener,carry_set_0.getCarry(2),CtCDPI_Cursor));
    1008                 if (bitblock::any(simd_or(simd_and(CtCDPI_Cursor,EOF_mask),carry_set_0.carryRange(3,13))))
     1007                CtCDPI_Cursor = pablo.ScanToFirst(CtCDPI_opener);
     1008                if (bitblock::any(simd_or(simd_and(CtCDPI_Cursor,EOF_mask),carry_set_0.carryRange(0,13))))
    10091009                {
    10101010                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
     
    10121012                        PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    10131013                        BitBlock CD_Ct_Cursor;
    1014                         carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.getCarry(3),CD_Ct_Cursor));
     1014                        CD_Ct_Cursor = pablo.Advance(simd_andc(CtCDPI_Cursor,PI_Cursor));
    10151015                        BitBlock CD_Cursor;
    10161016                        CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
    10171017                        BitBlock Ct_Cursor;
    10181018                        Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    1019                         if (bitblock::any(simd_or(PI_Cursor,carry_set_0.carryRange(4,4))))
     1019                        if (bitblock::any(simd_or(PI_Cursor,carry_set_0.carryRange(0,4))))
    10201020                        {
    10211021                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
    1022                                 carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_0.getCarry(4),PI_Cursor));
     1022                                PI_Cursor = pablo.Advance(PI_Cursor);
    10231023                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    10241024                                BitBlock PI_name_end;
    1025                                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_0.getCarry(5),PI_name_end));
     1025                                PI_name_end = pablo.ScanThru(PI_Cursor,lex.NameScan);
    10261026                                BitBlock PI_error;
    10271027                                PI_error = simd_and(PI_Cursor,PI_name_end);
     
    10291029                                PI_noWS = simd_andc(PI_name_end,lex.WS);
    10301030                                BitBlock _temp2;
    1031                                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_0.getCarry(6),_temp2));
     1031                                _temp2 = pablo.Advance(PI_noWS);
    10321032                                PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(_temp2,PI_closer)));
    10331033                                if (bitblock::any(PI_error))
     
    10361036                                }
    10371037                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
    1038                                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_andc(EOF_mask,PI_closer),carry_set_0.getCarry(7),PI_Cursor));
     1038                                PI_Cursor = pablo.ScanTo(PI_name_end,PI_closer);
    10391039                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    10401040                                CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     
    10421042                        else
    10431043                        {
    1044                                 carry_set_0.carryDequeueEnqueue(4,4);
    1045                         }
    1046                         if (bitblock::any(simd_or(CD_Cursor,carry_set_0.carryRange(8,1))))
     1044                                carry_set_0.carryDequeueEnqueue(0,4);
     1045                        }
     1046                        if (bitblock::any(simd_or(CD_Cursor,carry_set_0.carryRange(0,1))))
    10471047                        {
    10481048                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    1049                                 carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_andc(EOF_mask,CD_closer),carry_set_0.getCarry(8),CD_Cursor));
     1049                                CD_Cursor = pablo.ScanTo(CD_Cursor,CD_closer);
    10501050                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    10511051                                CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     
    10531053                        else
    10541054                        {
    1055                                 carry_set_0.carryDequeueEnqueue(8,1);
    1056                         }
    1057                         if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.carryRange(9,5))))
     1055                                carry_set_0.carryDequeueEnqueue(0,1);
     1056                        }
     1057                        if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.carryRange(0,5))))
    10581058                        {
    10591059                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
    1060                                 carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(9),Ct_Cursor));
     1060                                Ct_Cursor = pablo.Advance(Ct_Cursor);
    10611061                                BitBlock Ct_error;
    10621062                                Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    10631063                                BitBlock _temp3;
    1064                                 carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(10),_temp3));
    1065                                 carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_0.getCarry(11),Ct_Cursor));
     1064                                _temp3 = pablo.Advance(Ct_Cursor);
     1065                                Ct_Cursor = pablo.Advance(_temp3);
    10661066                                BitBlock _temp4;
    1067                                 carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_andc(EOF_mask,DoubleHyphen),carry_set_0.getCarry(12),_temp4));
    1068                                 carry_set_0.getCarry(13) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_0.getCarry(13),Ct_Cursor));
     1067                                _temp4 = pablo.ScanTo(Ct_Cursor,DoubleHyphen);
     1068                                Ct_Cursor = pablo.Advance(_temp4);
    10691069                                if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    10701070                                {
     
    10761076                        else
    10771077                        {
    1078                                 carry_set_0.carryDequeueEnqueue(9,5);
     1078                                carry_set_0.carryDequeueEnqueue(0,5);
    10791079                        }
    10801080                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
    1081                         carry_set_0.getCarry(14) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_0.getCarry(14),ctCDPI_mask));
     1081                        ctCDPI_mask = pablo.InclusiveSpan(CtCDPI_starts,CtCDPI_ends);
    10821082                        if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
    10831083                        {
    10841084                                assert_0_error(simd_andc(ctCDPI_mask,EOF_mask),"Error in comment, CDATA or processing instruction syntax");
    10851085                        }
    1086                         carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),carry_set_0.getCarry(15),CtCDPI_Cursor));
     1086                        CtCDPI_Cursor = pablo.ScanTo(CtCDPI_Cursor,CtCDPI_opener);
    10871087                        while (bitblock::any(simd_and(CtCDPI_Cursor,EOF_mask)))
    10881088                        {
     
    10921092                                PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    10931093                                BitBlock CD_Ct_Cursor;
    1094                                 carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_1.getCarry(0),CD_Ct_Cursor));
     1094                                CD_Ct_Cursor = pablo.Advance(simd_andc(CtCDPI_Cursor,PI_Cursor));
    10951095                                BitBlock CD_Cursor;
    10961096                                CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
     
    11001100                                {
    11011101                                        ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
    1102                                         carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_1.getCarry(1),PI_Cursor));
     1102                                        PI_Cursor = pablo.Advance(PI_Cursor);
    11031103                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    11041104                                        BitBlock PI_name_end;
    1105                                         carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_1.getCarry(2),PI_name_end));
     1105                                        PI_name_end = pablo.ScanThru(PI_Cursor,lex.NameScan);
    11061106                                        BitBlock PI_error;
    11071107                                        PI_error = simd_and(PI_Cursor,PI_name_end);
     
    11091109                                        PI_noWS = simd_andc(PI_name_end,lex.WS);
    11101110                                        BitBlock _temp2;
    1111                                         carry_set_1.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_1.getCarry(3),_temp2));
     1111                                        _temp2 = pablo.Advance(PI_noWS);
    11121112                                        PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(_temp2,PI_closer)));
    11131113                                        if (bitblock::any(PI_error))
     
    11161116                                        }
    11171117                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
    1118                                         carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_andc(EOF_mask,PI_closer),carry_set_1.getCarry(4),PI_Cursor));
     1118                                        PI_Cursor = pablo.ScanTo(PI_name_end,PI_closer);
    11191119                                        ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    11201120                                        CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     
    11231123                                {
    11241124                                        ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    1125                                         carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_andc(EOF_mask,CD_closer),carry_set_1.getCarry(5),CD_Cursor));
     1125                                        CD_Cursor = pablo.ScanTo(CD_Cursor,CD_closer);
    11261126                                        ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    11271127                                        CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     
    11301130                                {
    11311131                                        ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
    1132                                         carry_set_1.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(6),Ct_Cursor));
     1132                                        Ct_Cursor = pablo.Advance(Ct_Cursor);
    11331133                                        BitBlock Ct_error;
    11341134                                        Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    11351135                                        BitBlock _temp3;
    1136                                         carry_set_1.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(7),_temp3));
    1137                                         carry_set_1.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_1.getCarry(8),Ct_Cursor));
     1136                                        _temp3 = pablo.Advance(Ct_Cursor);
     1137                                        Ct_Cursor = pablo.Advance(_temp3);
    11381138                                        BitBlock _temp4;
    1139                                         carry_set_1.getCarry(9) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_andc(EOF_mask,DoubleHyphen),carry_set_1.getCarry(9),_temp4));
    1140                                         carry_set_1.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_1.getCarry(10),Ct_Cursor));
     1139                                        _temp4 = pablo.ScanTo(Ct_Cursor,DoubleHyphen);
     1140                                        Ct_Cursor = pablo.Advance(_temp4);
    11411141                                        if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    11421142                                        {
     
    11471147                                }
    11481148                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
    1149                                 carry_set_1.getCarry(11) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_1.getCarry(11),ctCDPI_mask));
     1149                                ctCDPI_mask = pablo.InclusiveSpan(CtCDPI_starts,CtCDPI_ends);
    11501150                                if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
    11511151                                {
    11521152                                        assert_0_error(simd_andc(ctCDPI_mask,EOF_mask),"Error in comment, CDATA or processing instruction syntax");
    11531153                                }
    1154                                 carry_set_1.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),carry_set_1.getCarry(12),CtCDPI_Cursor));
    1155                                 LocalCarryCombine(carry_set_0,carry_set_1,3,13);
     1154                                CtCDPI_Cursor = pablo.ScanTo(CtCDPI_Cursor,CtCDPI_opener);
     1155                                LocalCarryCombine(carry_set_0,carry_set_1,0,13);
    11561156                        }
    11571157                }
    11581158                else
    11591159                {
    1160                         carry_set_0.carryDequeueEnqueue(3,13);
     1160                        carry_set_0.carryDequeueEnqueue(0,13);
    11611161                }
    11621162                BitBlock _temp5;
    1163                 carry_set_0.getCarry(16) = bitblock::srli<127>(pablo_blk_InclusiveSpan(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),_temp5));
     1163                _temp5 = pablo.InclusiveSpan(simd_or(ctCDPI_Callouts.Ct_starts,ctCDPI_Callouts.PI_starts),simd_or(ctCDPI_Callouts.Ct_ends,ctCDPI_Callouts.PI_ends));
    11641164                check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS,lex.LAngle),_temp5),CtCDPI_starts),EOF_mask);
    11651165                marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
     
    11911191                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope,lex.Slash);
    11921192                tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope,lex.Slash);
    1193                 carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_starts,lex.NameScan,carry_set_0.getCarry(0),tag_Callouts.ElemName_ends));
     1193                tag_Callouts.ElemName_ends = pablo.ScanThru(tag_Callouts.ElemName_starts,lex.NameScan);
    11941194                BitBlock ParseError;
    11951195                ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
     
    11981198                tag_Callouts.AttVal_starts = simd<1>::constant<0>();
    11991199                tag_Callouts.AttVal_ends = simd<1>::constant<0>();
    1200                 if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.carryRange(1,8))))
     1200                if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.carryRange(0,8))))
    12011201                {
    12021202                        BitBlock AfterWS;
    1203                         carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_ends,lex.WS,carry_set_0.getCarry(1),AfterWS));
     1203                        AfterWS = pablo.ScanThru(tag_Callouts.ElemName_ends,lex.WS);
    12041204                        AttListEnd = simd_and(AfterWS,AttListDelim);
    12051205                        BitBlock AttNameStart;
    12061206                        AttNameStart = simd_andc(AfterWS,AttListDelim);
    1207                         if (bitblock::any(simd_or(AttNameStart,carry_set_0.carryRange(2,7))))
     1207                        if (bitblock::any(simd_or(AttNameStart,carry_set_0.carryRange(0,7))))
    12081208                        {
    12091209                                ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
    12101210                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
    12111211                                BitBlock AttNameFollow;
    1212                                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_0.getCarry(2),AttNameFollow));
     1212                                AttNameFollow = pablo.ScanThru(AttNameStart,lex.NameScan);
    12131213                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
    1214                                 if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.carryRange(3,1))))
    1215                                 {
    1216                                         carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_0.getCarry(3),EqExpected));
     1214                                if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.carryRange(0,1))))
     1215                                {
     1216                                        EqExpected = pablo.ScanThru(AttNameFollow,lex.WS);
    12171217                                }
    12181218                                else
    12191219                                {
    12201220                                        EqExpected = AttNameFollow;
    1221                                         carry_set_0.carryDequeueEnqueue(3,1);
     1221                                        carry_set_0.carryDequeueEnqueue(0,1);
    12221222                                }
    12231223                                ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
    12241224                                BitBlock AttValPos;
    1225                                 carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_0.getCarry(4),AttValPos));
     1225                                AttValPos = pablo.AdvanceThenScanThru(EqExpected,lex.WS);
    12261226                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
    12271227                                BitBlock DQuoteAttVal;
     
    12301230                                SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    12311231                                BitBlock DQuoteAttEnd;
    1232                                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_not(DQuoteDelim),carry_set_0.getCarry(5),DQuoteAttEnd));
     1232                                DQuoteAttEnd = pablo.AdvanceThenScanTo(DQuoteAttVal,DQuoteDelim);
    12331233                                BitBlock SQuoteAttEnd;
    1234                                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_not(SQuoteDelim),carry_set_0.getCarry(6),SQuoteAttEnd));
     1234                                SQuoteAttEnd = pablo.AdvanceThenScanTo(SQuoteAttVal,SQuoteDelim);
    12351235                                BitBlock AttValEnd;
    12361236                                AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
    12371237                                ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
    12381238                                BitBlock AttValFollow;
    1239                                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(7),AttValFollow));
     1239                                AttValFollow = pablo.Advance(AttValEnd);
    12401240                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
    1241                                 if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.carryRange(8,1))))
    1242                                 {
    1243                                         carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_0.getCarry(8),AfterWS));
     1241                                if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.carryRange(0,1))))
     1242                                {
     1243                                        AfterWS = pablo.ScanThru(AttValFollow,lex.WS);
    12441244                                        AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
    12451245                                        AttNameStart = simd_andc(AfterWS,AttListDelim);
     
    12491249                                        AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
    12501250                                        AttNameStart = simd_andc(AttValFollow,AttListDelim);
    1251                                         carry_set_0.carryDequeueEnqueue(8,1);
     1251                                        carry_set_0.carryDequeueEnqueue(0,1);
    12521252                                }
    12531253                                ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
     
    12581258                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
    12591259                                        BitBlock AttNameFollow;
    1260                                         carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_1.getCarry(0),AttNameFollow));
     1260                                        AttNameFollow = pablo.ScanThru(AttNameStart,lex.NameScan);
    12611261                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
    12621262                                        if (bitblock::any(simd_and(AttNameFollow,lex.WS)))
    12631263                                        {
    1264                                                 carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_1.getCarry(1),EqExpected));
     1264                                                EqExpected = pablo.ScanThru(AttNameFollow,lex.WS);
    12651265                                        }
    12661266                                        else
     
    12701270                                        ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
    12711271                                        BitBlock AttValPos;
    1272                                         carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_1.getCarry(2),AttValPos));
     1272                                        AttValPos = pablo.AdvanceThenScanThru(EqExpected,lex.WS);
    12731273                                        tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
    12741274                                        BitBlock DQuoteAttVal;
     
    12771277                                        SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    12781278                                        BitBlock DQuoteAttEnd;
    1279                                         carry_set_1.getCarry(3) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_not(DQuoteDelim),carry_set_1.getCarry(3),DQuoteAttEnd));
     1279                                        DQuoteAttEnd = pablo.AdvanceThenScanTo(DQuoteAttVal,DQuoteDelim);
    12801280                                        BitBlock SQuoteAttEnd;
    1281                                         carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_not(SQuoteDelim),carry_set_1.getCarry(4),SQuoteAttEnd));
     1281                                        SQuoteAttEnd = pablo.AdvanceThenScanTo(SQuoteAttVal,SQuoteDelim);
    12821282                                        BitBlock AttValEnd;
    12831283                                        AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
    12841284                                        ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
    12851285                                        BitBlock AttValFollow;
    1286                                         carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_1.getCarry(5),AttValFollow));
     1286                                        AttValFollow = pablo.Advance(AttValEnd);
    12871287                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
    12881288                                        if (bitblock::any(simd_and(AttValFollow,lex.WS)))
    12891289                                        {
    1290                                                 carry_set_1.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_1.getCarry(6),AfterWS));
     1290                                                AfterWS = pablo.ScanThru(AttValFollow,lex.WS);
    12911291                                                AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
    12921292                                                AttNameStart = simd_andc(AfterWS,AttListDelim);
     
    12981298                                        }
    12991299                                        ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
    1300                                         LocalCarryCombine(carry_set_0,carry_set_1,2,7);
     1300                                        LocalCarryCombine(carry_set_0,carry_set_1,0,7);
    13011301                                }
    13021302                        }
    13031303                        else
    13041304                        {
    1305                                 carry_set_0.carryDequeueEnqueue(2,7);
     1305                                carry_set_0.carryDequeueEnqueue(0,7);
    13061306                        }
    13071307                }
     
    13101310                        AttListEnd = simd_and(tag_Callouts.ElemName_ends,AttListDelim);
    13111311                        ParseError = simd_or(ParseError,simd_andc(tag_Callouts.ElemName_ends,AttListDelim));
    1312                         carry_set_0.carryDequeueEnqueue(1,8);
     1312                        carry_set_0.carryDequeueEnqueue(0,8);
    13131313                }
    13141314                BitBlock STagEnds;
    13151315                STagEnds = simd_and(AttListEnd,lex.RAngle);
    1316                 carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(simd_and(AttListEnd,lex.Slash),carry_set_0.getCarry(9),tag_Callouts.EmptyTag_marks));
     1316                tag_Callouts.EmptyTag_marks = pablo.Advance(simd_and(AttListEnd,lex.Slash));
    13171317                ParseError = simd_or(ParseError,simd_andc(tag_Callouts.EmptyTag_marks,lex.RAngle));
    13181318                BitBlock EndTagEnds;
    1319                 carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.getCarry(10),EndTagEnds));
    1320                 if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.carryRange(11,1))))
    1321                 {
    1322                         carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_ScanThru(EndTagEnds,lex.WS,carry_set_0.getCarry(11),EndTagEnds));
     1319                EndTagEnds = pablo.AdvanceThenScanThru(tag_Callouts.EndTag_marks,lex.NameScan);
     1320                if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.carryRange(0,1))))
     1321                {
     1322                        EndTagEnds = pablo.ScanThru(EndTagEnds,lex.WS);
    13231323                }
    13241324                else
    13251325                {
    1326                         carry_set_0.carryDequeueEnqueue(11,1);
     1326                        carry_set_0.carryDequeueEnqueue(0,1);
    13271327                }
    13281328                ParseError = simd_or(ParseError,simd_andc(EndTagEnds,lex.RAngle));
     
    13311331                        assert_0_error(ParseError,"Tag parsing error found");
    13321332                }
    1333                 carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends,carry_set_0.getCarry(12),tag_Callouts.AttVal_spans));
     1333                tag_Callouts.AttVal_spans = pablo.SpanUpTo(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends);
    13341334                carry_set_0.carryAdjust(13);
    13351335        }
     
    13491349                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope,lex.Slash);
    13501350                tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope,lex.Slash);
    1351                 carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_starts,lex.NameScan,carry_set_0.getCarry(0),tag_Callouts.ElemName_ends));
     1351                tag_Callouts.ElemName_ends = pablo.ScanThru(tag_Callouts.ElemName_starts,lex.NameScan);
    13521352                BitBlock ParseError;
    13531353                ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
     
    13561356                tag_Callouts.AttVal_starts = simd<1>::constant<0>();
    13571357                tag_Callouts.AttVal_ends = simd<1>::constant<0>();
    1358                 if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.carryRange(1,8))))
     1358                if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.carryRange(0,8))))
    13591359                {
    13601360                        BitBlock AfterWS;
    1361                         carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_ends,lex.WS,carry_set_0.getCarry(1),AfterWS));
     1361                        AfterWS = pablo.ScanThru(tag_Callouts.ElemName_ends,lex.WS);
    13621362                        AttListEnd = simd_and(AfterWS,AttListDelim);
    13631363                        BitBlock AttNameStart;
    13641364                        AttNameStart = simd_andc(AfterWS,AttListDelim);
    1365                         if (bitblock::any(simd_or(simd_and(AttNameStart,EOF_mask),carry_set_0.carryRange(2,7))))
     1365                        if (bitblock::any(simd_or(simd_and(AttNameStart,EOF_mask),carry_set_0.carryRange(0,7))))
    13661366                        {
    13671367                                ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
    13681368                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
    13691369                                BitBlock AttNameFollow;
    1370                                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_0.getCarry(2),AttNameFollow));
     1370                                AttNameFollow = pablo.ScanThru(AttNameStart,lex.NameScan);
    13711371                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
    1372                                 if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.carryRange(3,1))))
    1373                                 {
    1374                                         carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_0.getCarry(3),EqExpected));
     1372                                if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.carryRange(0,1))))
     1373                                {
     1374                                        EqExpected = pablo.ScanThru(AttNameFollow,lex.WS);
    13751375                                }
    13761376                                else
    13771377                                {
    13781378                                        EqExpected = AttNameFollow;
    1379                                         carry_set_0.carryDequeueEnqueue(3,1);
     1379                                        carry_set_0.carryDequeueEnqueue(0,1);
    13801380                                }
    13811381                                ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
    13821382                                BitBlock AttValPos;
    1383                                 carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_0.getCarry(4),AttValPos));
     1383                                AttValPos = pablo.AdvanceThenScanThru(EqExpected,lex.WS);
    13841384                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
    13851385                                BitBlock DQuoteAttVal;
     
    13881388                                SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    13891389                                BitBlock DQuoteAttEnd;
    1390                                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_andc(EOF_mask,DQuoteDelim),carry_set_0.getCarry(5),DQuoteAttEnd));
     1390                                DQuoteAttEnd = pablo.AdvanceThenScanTo(DQuoteAttVal,DQuoteDelim);
    13911391                                BitBlock SQuoteAttEnd;
    1392                                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_andc(EOF_mask,SQuoteDelim),carry_set_0.getCarry(6),SQuoteAttEnd));
     1392                                SQuoteAttEnd = pablo.AdvanceThenScanTo(SQuoteAttVal,SQuoteDelim);
    13931393                                BitBlock AttValEnd;
    13941394                                AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
    13951395                                ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
    13961396                                BitBlock AttValFollow;
    1397                                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(7),AttValFollow));
     1397                                AttValFollow = pablo.Advance(AttValEnd);
    13981398                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
    1399                                 if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.carryRange(8,1))))
    1400                                 {
    1401                                         carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_0.getCarry(8),AfterWS));
     1399                                if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.carryRange(0,1))))
     1400                                {
     1401                                        AfterWS = pablo.ScanThru(AttValFollow,lex.WS);
    14021402                                        AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
    14031403                                        AttNameStart = simd_andc(AfterWS,AttListDelim);
     
    14071407                                        AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
    14081408                                        AttNameStart = simd_andc(AttValFollow,AttListDelim);
    1409                                         carry_set_0.carryDequeueEnqueue(8,1);
     1409                                        carry_set_0.carryDequeueEnqueue(0,1);
    14101410                                }
    14111411                                ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
     
    14161416                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
    14171417                                        BitBlock AttNameFollow;
    1418                                         carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_1.getCarry(0),AttNameFollow));
     1418                                        AttNameFollow = pablo.ScanThru(AttNameStart,lex.NameScan);
    14191419                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
    14201420                                        if (bitblock::any(simd_and(AttNameFollow,lex.WS)))
    14211421                                        {
    1422                                                 carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_1.getCarry(1),EqExpected));
     1422                                                EqExpected = pablo.ScanThru(AttNameFollow,lex.WS);
    14231423                                        }
    14241424                                        else
     
    14281428                                        ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
    14291429                                        BitBlock AttValPos;
    1430                                         carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_1.getCarry(2),AttValPos));
     1430                                        AttValPos = pablo.AdvanceThenScanThru(EqExpected,lex.WS);
    14311431                                        tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
    14321432                                        BitBlock DQuoteAttVal;
     
    14351435                                        SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    14361436                                        BitBlock DQuoteAttEnd;
    1437                                         carry_set_1.getCarry(3) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_andc(EOF_mask,DQuoteDelim),carry_set_1.getCarry(3),DQuoteAttEnd));
     1437                                        DQuoteAttEnd = pablo.AdvanceThenScanTo(DQuoteAttVal,DQuoteDelim);
    14381438                                        BitBlock SQuoteAttEnd;
    1439                                         carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_andc(EOF_mask,SQuoteDelim),carry_set_1.getCarry(4),SQuoteAttEnd));
     1439                                        SQuoteAttEnd = pablo.AdvanceThenScanTo(SQuoteAttVal,SQuoteDelim);
    14401440                                        BitBlock AttValEnd;
    14411441                                        AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
    14421442                                        ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
    14431443                                        BitBlock AttValFollow;
    1444                                         carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_1.getCarry(5),AttValFollow));
     1444                                        AttValFollow = pablo.Advance(AttValEnd);
    14451445                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
    14461446                                        if (bitblock::any(simd_and(AttValFollow,lex.WS)))
    14471447                                        {
    1448                                                 carry_set_1.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_1.getCarry(6),AfterWS));
     1448                                                AfterWS = pablo.ScanThru(AttValFollow,lex.WS);
    14491449                                                AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
    14501450                                                AttNameStart = simd_andc(AfterWS,AttListDelim);
     
    14561456                                        }
    14571457                                        ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
    1458                                         LocalCarryCombine(carry_set_0,carry_set_1,2,7);
     1458                                        LocalCarryCombine(carry_set_0,carry_set_1,0,7);
    14591459                                }
    14601460                        }
    14611461                        else
    14621462                        {
    1463                                 carry_set_0.carryDequeueEnqueue(2,7);
     1463                                carry_set_0.carryDequeueEnqueue(0,7);
    14641464                        }
    14651465                }
     
    14681468                        AttListEnd = simd_and(tag_Callouts.ElemName_ends,AttListDelim);
    14691469                        ParseError = simd_or(ParseError,simd_andc(tag_Callouts.ElemName_ends,AttListDelim));
    1470                         carry_set_0.carryDequeueEnqueue(1,8);
     1470                        carry_set_0.carryDequeueEnqueue(0,8);
    14711471                }
    14721472                BitBlock STagEnds;
    14731473                STagEnds = simd_and(AttListEnd,lex.RAngle);
    1474                 carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(simd_and(AttListEnd,lex.Slash),carry_set_0.getCarry(9),tag_Callouts.EmptyTag_marks));
     1474                tag_Callouts.EmptyTag_marks = pablo.Advance(simd_and(AttListEnd,lex.Slash));
    14751475                ParseError = simd_or(ParseError,simd_andc(tag_Callouts.EmptyTag_marks,lex.RAngle));
    14761476                BitBlock EndTagEnds;
    1477                 carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.getCarry(10),EndTagEnds));
    1478                 if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.carryRange(11,1))))
    1479                 {
    1480                         carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_ScanThru(EndTagEnds,lex.WS,carry_set_0.getCarry(11),EndTagEnds));
     1477                EndTagEnds = pablo.AdvanceThenScanThru(tag_Callouts.EndTag_marks,lex.NameScan);
     1478                if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.carryRange(0,1))))
     1479                {
     1480                        EndTagEnds = pablo.ScanThru(EndTagEnds,lex.WS);
    14811481                }
    14821482                else
    14831483                {
    1484                         carry_set_0.carryDequeueEnqueue(11,1);
     1484                        carry_set_0.carryDequeueEnqueue(0,1);
    14851485                }
    14861486                ParseError = simd_or(ParseError,simd_andc(EndTagEnds,lex.RAngle));
     
    14891489                        assert_0_error(ParseError,"Tag parsing error found");
    14901490                }
    1491                 carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends,carry_set_0.getCarry(12),tag_Callouts.AttVal_spans));
     1491                tag_Callouts.AttVal_spans = pablo.SpanUpTo(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends);
    14921492        }
    14931493       
     
    15141514                {
    15151515                        BitBlock Ref_scope;
    1516                         carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(marker.Ref_opener,carry_set_0.getCarry(0),Ref_scope));
     1516                        Ref_scope = pablo.Advance(marker.Ref_opener);
    15171517                        BitBlock NumRef2;
    15181518                        NumRef2 = simd_and(Ref_scope,lex.Hash);
    15191519                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope,lex.Hash);
    15201520                        BitBlock NumRef3;
    1521                         carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(NumRef2,carry_set_0.getCarry(1),NumRef3));
     1521                        NumRef3 = pablo.Advance(NumRef2);
    15221522                        BitBlock HexRef3;
    15231523                        HexRef3 = simd_and(NumRef3,lex.x);
    15241524                        ref_Callouts.DecRef_starts = simd_andc(NumRef3,lex.x);
    1525                         carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(HexRef3,carry_set_0.getCarry(2),ref_Callouts.HexRef_starts));
    1526                         carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.GenRef_starts,lex.NameScan,carry_set_0.getCarry(3),ref_Callouts.GenRef_ends));
    1527                         carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.DecRef_starts,lex.Digit,carry_set_0.getCarry(4),ref_Callouts.DecRef_ends));
    1528                         carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.HexRef_starts,lex.Hex,carry_set_0.getCarry(5),ref_Callouts.HexRef_ends));
     1525                        ref_Callouts.HexRef_starts = pablo.Advance(HexRef3);
     1526                        ref_Callouts.GenRef_ends = pablo.ScanThru(ref_Callouts.GenRef_starts,lex.NameScan);
     1527                        ref_Callouts.DecRef_ends = pablo.ScanThru(ref_Callouts.DecRef_starts,lex.Digit);
     1528                        ref_Callouts.HexRef_ends = pablo.ScanThru(ref_Callouts.HexRef_starts,lex.Hex);
    15291529                        BitBlock ref_error1;
    15301530                        ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
     
    15601560                {
    15611561                        BitBlock Ref_scope;
    1562                         carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(marker.Ref_opener,carry_set_0.getCarry(0),Ref_scope));
     1562                        Ref_scope = pablo.Advance(marker.Ref_opener);
    15631563                        BitBlock NumRef2;
    15641564                        NumRef2 = simd_and(Ref_scope,lex.Hash);
    15651565                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope,lex.Hash);
    15661566                        BitBlock NumRef3;
    1567                         carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(NumRef2,carry_set_0.getCarry(1),NumRef3));
     1567                        NumRef3 = pablo.Advance(NumRef2);
    15681568                        BitBlock HexRef3;
    15691569                        HexRef3 = simd_and(NumRef3,lex.x);
    15701570                        ref_Callouts.DecRef_starts = simd_andc(NumRef3,lex.x);
    1571                         carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(HexRef3,carry_set_0.getCarry(2),ref_Callouts.HexRef_starts));
    1572                         carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.GenRef_starts,lex.NameScan,carry_set_0.getCarry(3),ref_Callouts.GenRef_ends));
    1573                         carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.DecRef_starts,lex.Digit,carry_set_0.getCarry(4),ref_Callouts.DecRef_ends));
    1574                         carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.HexRef_starts,lex.Hex,carry_set_0.getCarry(5),ref_Callouts.HexRef_ends));
     1571                        ref_Callouts.HexRef_starts = pablo.Advance(HexRef3);
     1572                        ref_Callouts.GenRef_ends = pablo.ScanThru(ref_Callouts.GenRef_starts,lex.NameScan);
     1573                        ref_Callouts.DecRef_ends = pablo.ScanThru(ref_Callouts.DecRef_starts,lex.Digit);
     1574                        ref_Callouts.HexRef_ends = pablo.ScanThru(ref_Callouts.HexRef_starts,lex.Hex);
    15751575                        BitBlock ref_error1;
    15761576                        ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
     
    16041604        {
    16051605                BitBlock PI_names;
    1606                 carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_SpanUpTo(ctCDPI_Callouts.PI_name_starts,ctCDPI_Callouts.PI_name_ends,carry_set_0.getCarry(0),PI_names));
     1606                PI_names = pablo.SpanUpTo(ctCDPI_Callouts.PI_name_starts,ctCDPI_Callouts.PI_name_ends);
    16071607                BitBlock GenRefs;
    1608                 carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_SpanUpTo(ref_Callouts.GenRef_starts,ref_Callouts.GenRef_ends,carry_set_0.getCarry(1),GenRefs));
     1608                GenRefs = pablo.SpanUpTo(ref_Callouts.GenRef_starts,ref_Callouts.GenRef_ends);
    16091609                BitBlock ElemNames;
    1610                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends,carry_set_0.getCarry(2),ElemNames));
     1610                ElemNames = pablo.SpanUpTo(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
    16111611                BitBlock AttNames;
    1612                 carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttName_starts,tag_Callouts.AttName_ends,carry_set_0.getCarry(3),AttNames));
     1612                AttNames = pablo.SpanUpTo(tag_Callouts.AttName_starts,tag_Callouts.AttName_ends);
    16131613                BitBlock qname_stream;
    16141614                qname_stream = simd_or(ElemNames,AttNames);
     
    16191619                BitBlock name_start;
    16201620                BitBlock _temp0;
    1621                 carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(4),_temp0));
     1621                _temp0 = pablo.Advance(name_stream);
    16221622                name_start = simd_andc(name_stream,_temp0);
    16231623                BitBlock name_cursor;
    16241624                BitBlock _temp1;
    1625                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(5),_temp1));
     1625                _temp1 = pablo.Advance(name_stream);
    16261626                name_cursor = simd_andc(name_stream,_temp1);
    16271627                BitBlock void_prefix_err;
     
    16291629                BitBlock namespace_sep;
    16301630                BitBlock _temp2;
    1631                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(name_cursor,simd_andc(lex.NameScan,lex.Colon),carry_set_0.getCarry(6),_temp2));
     1631                _temp2 = pablo.ScanThru(name_cursor,simd_andc(lex.NameScan,lex.Colon));
    16321632                namespace_sep = simd_and(_temp2,lex.Colon);
    16331633                BitBlock local_part_start;
    1634                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(namespace_sep,carry_set_0.getCarry(7),local_part_start));
     1634                local_part_start = pablo.Advance(namespace_sep);
    16351635                BitBlock local_part_err;
    16361636                local_part_err = simd_andc(local_part_start,lex.NameScan);
    16371637                BitBlock colon2_err;
    16381638                BitBlock _temp3;
    1639                 carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(local_part_start,simd_andc(lex.NameScan,lex.Colon),carry_set_0.getCarry(8),_temp3));
     1639                _temp3 = pablo.ScanThru(local_part_start,simd_andc(lex.NameScan,lex.Colon));
    16401640                colon2_err = simd_and(_temp3,lex.Colon);
    16411641                BitBlock ncname_err;
     
    16531653        {
    16541654                BitBlock PI_names;
    1655                 carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_SpanUpTo(ctCDPI_Callouts.PI_name_starts,ctCDPI_Callouts.PI_name_ends,carry_set_0.getCarry(0),PI_names));
     1655                PI_names = pablo.SpanUpTo(ctCDPI_Callouts.PI_name_starts,ctCDPI_Callouts.PI_name_ends);
    16561656                BitBlock GenRefs;
    1657                 carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_SpanUpTo(ref_Callouts.GenRef_starts,ref_Callouts.GenRef_ends,carry_set_0.getCarry(1),GenRefs));
     1657                GenRefs = pablo.SpanUpTo(ref_Callouts.GenRef_starts,ref_Callouts.GenRef_ends);
    16581658                BitBlock ElemNames;
    1659                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends,carry_set_0.getCarry(2),ElemNames));
     1659                ElemNames = pablo.SpanUpTo(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
    16601660                BitBlock AttNames;
    1661                 carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttName_starts,tag_Callouts.AttName_ends,carry_set_0.getCarry(3),AttNames));
     1661                AttNames = pablo.SpanUpTo(tag_Callouts.AttName_starts,tag_Callouts.AttName_ends);
    16621662                BitBlock qname_stream;
    16631663                qname_stream = simd_or(ElemNames,AttNames);
     
    16681668                BitBlock name_start;
    16691669                BitBlock _temp0;
    1670                 carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(4),_temp0));
     1670                _temp0 = pablo.Advance(name_stream);
    16711671                name_start = simd_andc(name_stream,_temp0);
    16721672                BitBlock name_cursor;
    16731673                BitBlock _temp1;
    1674                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(5),_temp1));
     1674                _temp1 = pablo.Advance(name_stream);
    16751675                name_cursor = simd_andc(name_stream,_temp1);
    16761676                BitBlock void_prefix_err;
     
    16781678                BitBlock namespace_sep;
    16791679                BitBlock _temp2;
    1680                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(name_cursor,simd_andc(lex.NameScan,lex.Colon),carry_set_0.getCarry(6),_temp2));
     1680                _temp2 = pablo.ScanThru(name_cursor,simd_andc(lex.NameScan,lex.Colon));
    16811681                namespace_sep = simd_and(_temp2,lex.Colon);
    16821682                BitBlock local_part_start;
    1683                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(namespace_sep,carry_set_0.getCarry(7),local_part_start));
     1683                local_part_start = pablo.Advance(namespace_sep);
    16841684                BitBlock local_part_err;
    16851685                local_part_err = simd_andc(local_part_start,lex.NameScan);
    16861686                BitBlock colon2_err;
    16871687                BitBlock _temp3;
    1688                 carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(local_part_start,simd_andc(lex.NameScan,lex.Colon),carry_set_0.getCarry(8),_temp3));
     1688                _temp3 = pablo.ScanThru(local_part_start,simd_andc(lex.NameScan,lex.Colon));
    16891689                colon2_err = simd_and(_temp3,lex.Colon);
    16901690                BitBlock ncname_err;
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/infoSet/InfoSetMap.java

    r3362 r3376  
    2121public class InfoSetMap {
    2222       
    23         static public Map<ASTNode, StreamFunctionInfoSet> forTree(ASTNode ASTree) {
     23        static public Map<ASTNode, PropertyInfoSet> forTree(ASTNode ASTree) {
    2424           
    2525            PropertyInformationSetVisitor setter = new PropertyInformationSetVisitor();
     
    3030    static private class PropertyInformationSetVisitor extends VoidVisitor.Default {
    3131
    32         private Map<ASTNode, StreamFunctionInfoSet> propInfoSetMap;
     32        private Map<ASTNode, PropertyInfoSet> infoSetMap;
    3333       
    3434        private int carry1Position;
     
    3737        private List<Integer> carry1InitialValues;
    3838       
    39         public Map<ASTNode, StreamFunctionInfoSet> getPropertyInformationSet() {
    40             return propInfoSetMap;
     39        public Map<ASTNode, PropertyInfoSet> getPropertyInformationSet() {
     40            return infoSetMap;
    4141        }
    4242       
    4343        public PropertyInformationSetVisitor() {
    44             propInfoSetMap = new HashMap<ASTNode, StreamFunctionInfoSet>();
     44            infoSetMap = new HashMap<ASTNode, PropertyInfoSet>();
    4545        }
    4646       
     
    5353       
    5454        public void visitLeave(FuncDefNode node) {
    55             StreamFunctionInfoSet propInfoSet = new StreamFunctionInfoSet(carry1Position, carryNPosition, Carry1Count.forTree(node), CarryNCount.forTree(node));
    56             propInfoSetMap.put(node, propInfoSet);
     55            PropertyInfoSet propInfoSet = new PropertyInfoSet(carry1Position, carryNPosition, Carry1Count.forTree(node), CarryNCount.forTree(node));
     56            infoSetMap.put(node, propInfoSet);
    5757        }
    5858       
    5959        public void visitLeave(WhileStmtNode node) {
    60             StreamFunctionInfoSet propInfoSet = new StreamFunctionInfoSet(carry1Position, carryNPosition, Carry1Count.forTree(node), CarryNCount.forTree(node));
    61             propInfoSetMap.put(node, propInfoSet);
     60            PropertyInfoSet propInfoSet = new PropertyInfoSet(carry1Position, carryNPosition, Carry1Count.forTree(node), CarryNCount.forTree(node));
     61            infoSetMap.put(node, propInfoSet);
    6262        }
    6363       
    6464        public void visitLeave(IfStmtNode node) {
    65             StreamFunctionInfoSet propInfoSet = new StreamFunctionInfoSet(carry1Position, carryNPosition, Carry1Count.forTree(node), CarryNCount.forTree(node));
    66             propInfoSetMap.put(node, propInfoSet);
     65            PropertyInfoSet propInfoSet = new PropertyInfoSet(carry1Position, carryNPosition, Carry1Count.forTree(node), CarryNCount.forTree(node));
     66            infoSetMap.put(node, propInfoSet);
    6767        }
    6868       
     
    7575            }
    7676           
    77             if(BuiltinCallUtil.isCarry(node)) {
    78                 int initialValue = BuiltinCallUtil.builtin(node).intInitialValue();
    79                 carry1InitialValues.add(initialValue);
    80             }
     77//            if(BuiltinCallUtil.isCarry(node)) {
     78//                int initialValue = BuiltinCallUtil.builtin(node).intInitialValue();
     79//                carry1InitialValues.add(initialValue);
     80//            }
    8181           
    82             StreamFunctionInfoSet propInfoSet = new StreamFunctionInfoSet(carry1Position, carryNPosition);
    83             propInfoSetMap.put(node, propInfoSet);
     82            PropertyInfoSet propInfoSet = new PropertyInfoSet(carry1Position, carryNPosition);
     83           
     84           
     85           
     86           
     87            infoSetMap.put(node, propInfoSet);
    8488        }
    8589        }
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/infoSet/PropertyInfoSet.java

    r3367 r3376  
    33import java.util.ArrayList;
    44
    5 public class StreamFunctionInfoSet {
     5public class PropertyInfoSet {
    66
    77    // members
     
    1717    private ArrayList<Integer> carry1InitialValues;
    1818   
    19     public StreamFunctionInfoSet(int carry1Position, int carryNPosition) { 
     19    public PropertyInfoSet(int carry1Position, int carryNPosition) { 
    2020        this(carry1Position, carryNPosition, 0, 0, 0, 0);
    2121    }
    2222   
    23     public StreamFunctionInfoSet(int carry1Position, int carryNPosition, int carry1Count, int carryNCount) {
     23    public PropertyInfoSet(int carry1Position, int carryNPosition, int carry1Count, int carryNCount) {
    2424        this(carry1Position, carryNPosition, carry1Count, carryNCount, 0, 0);
    2525    } 
    2626
    27     public StreamFunctionInfoSet(int carry1Position, int carryNPosition, int carry1Count, int carryNCount, int lookAhead, int lookBehind) { 
    28        
     27    public PropertyInfoSet(int carry1Position, int carryNPosition, int carry1Count, int carryNCount, int lookAhead, int lookBehind) { 
    2928        this.setCarry1Position(carry1Position);
    3029        this.setCarryNPosition(carryNPosition);
     
    4039    }
    4140
    42     public int getCarry1Position() {
     41    public int carry1Position() {
    4342        return carry1Position;
    4443    }
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/pabloS2PabloB/CarryIntroXFormer.java

    r3375 r3376  
    176176
    177177                    ASTNode rhs = Accessors.rhs(node);
    178                     if(BuiltinCallUtil.isCarry(rhs)) {
    179                         ASTNode lhs = Accessors.lhs(node);
    180                        
    181                 FuncCallNode funcCall = (FuncCallNode) rhs;
    182                
    183                 PabloSBuiltin builtin = BuiltinCallUtil.builtin(funcCall);
    184                 Counter counter = selectCounter(builtin, carryCounter, advanceNCounter);
    185                 PabloSBuiltinTranslator translator = builtin.getTranslator();
    186                 ASTNode returnValue = lhs.deepCopy();
    187                 translator.translate(builtin, funcCall, counter, context, returnValue);
    188                
    189                 Locator locator = node;
    190                 node.replaceChild(lhs, Generators.makeGetCallCarryForBuiltin(locator, builtin, counter.value(), context));
    191                
    192                 counter.increment();
    193                     }
     178//                  if(BuiltinCallUtil.isCarry(rhs)) {
     179//                      ASTNode lhs = Accessors.lhs(node);
     180//                     
     181//                FuncCallNode funcCall = (FuncCallNode) rhs;
     182//               
     183//                PabloSBuiltin builtin = BuiltinCallUtil.builtin(funcCall);
     184//                Counter counter = selectCounter(builtin, carryCounter, advanceNCounter);
     185//                PabloSBuiltinTranslator translator = builtin.getTranslator();
     186//                ASTNode returnValue = lhs.deepCopy();
     187//                translator.translate(builtin, funcCall, counter, context, returnValue);
     188//               
     189//                Locator locator = node;
     190//                node.replaceChild(lhs, Generators.makeGetCallCarryForBuiltin(locator, builtin, counter.value(), context));
     191//               
     192//                counter.increment();
     193//                  }
    194194                }
    195195           
    196196                ///////////////////////////////////////////////////////////////////
    197197                // FuncCallNode
    198                
    199                 public void visitLeave(FuncCallNode node) {
    200                         if(BuiltinCallUtil.isCarryNone(node)) {
    201                             if(!BuiltinCallUtil.isAssertZero(node) && !BuiltinCallUtil.isMask(node) && !BuiltinCallUtil.isInFile(node) && !BuiltinCallUtil.isAtEOF(node)) {
    202                            
    203                                 PabloSBuiltin builtin = BuiltinCallUtil.builtin(node);
    204                                 Counter counter = selectCounter(builtin, carryCounter, advanceNCounter);
    205                                 PabloSBuiltinTranslator translator = builtin.getTranslator();
    206                                 translator.translate(builtin, node, counter, context);
    207 
    208                             }
    209                         }       
    210                 }
    211198
    212199                private static Counter selectCounter(PabloSBuiltin builtin, Counter advance1Counter, Counter advanceNCounter) {
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/pabloS2PabloB/PabloS2PabloBXFormer.java

    r3375 r3376  
    3030
    3131
    32 import toolchain.pabloS.transformer.visitors.infoSet.StreamFunctionInfoSet;
     32import toolchain.pabloS.transformer.visitors.infoSet.InfoSetMap;
     33import toolchain.pabloS.transformer.visitors.infoSet.PropertyInfoSet;
    3334import toolchain.pabloS.transformer.visitors.pabloS2pabloS.SomeNameStreamFunctionPropertySet;
    3435
     
    4546    private static CarrySetEncoder carrySetEncoder;
    4647
    47     Map<ASTNode, StreamFunctionInfoSet> propertyInfoSetMap;
     48    Map<ASTNode, PropertyInfoSet> propertyInfoSetMap;
    4849
    4950    public static void setStreamFunctionPropertySetMap(Map<String, SomeNameStreamFunctionPropertySet> map) {
     
    5960    }
    6061
    61     public static pabloB.ast.ASTNode apply(pabloS.ast.ASTNode decoratedASTreeS, pabloS.ast.ASTNode finalDecoratedASTTreeS) {
     62    public static pabloB.ast.ASTNode apply(pabloS.ast.ASTNode sASTree, pabloS.ast.ASTNode sFinalASTree) {
    6263
    6364        //////////////////////////////////////////////////////////////
    6465        // Prepare
    65         // Map<ASTNode, StreamFunctionInfoSet> propertyInfoSetMap = InfoSetMap.forTree(decoratedASTree);
    66 
    67         // Map<pabloB.ast.ASTNode, pabloS.ast.ASTNode> B2SMap;
    68 
    69         pabloB.ast.ASTNode ASTree               = decoratedASTreeS.accept(new ASTBuilder(false));        // TODO - KH: context object
    70         pabloB.ast.ASTNode finalASTree      = finalDecoratedASTTreeS.accept(new ASTBuilder(true));
    71 
    72         Map<String, pabloB.ast.FuncDefNode> map              = makeFuncDefMap(ASTree);
    73         Map<String, pabloB.ast.FuncDefNode> finalMap     = makeFuncDefMap(finalASTree );
    74 
    75         for (Map.Entry<String, pabloB.ast.FuncDefNode> entry : map.entrySet())
     66        Map<pabloS.ast.ASTNode, PropertyInfoSet> infoSetMap = InfoSetMap.forTree(sASTree);
     67        Map<pabloS.ast.ASTNode, PropertyInfoSet> finalInfoSetMap = InfoSetMap.forTree(sASTree);
     68
     69        ASTNode ASTree          = sASTree.accept(new ASTBuilder(infoSetMap,false));        // TODO - KH: context object stuff, property info set, ...
     70        ASTNode finalASTree      = sFinalASTree.accept(new ASTBuilder(finalInfoSetMap, true));
     71
     72        Map<String, FuncDefNode> map         = makeFuncDefMap(ASTree);
     73        Map<String, FuncDefNode> finalMap        = makeFuncDefMap(finalASTree );
     74
     75        for (Map.Entry<String, FuncDefNode> entry : map.entrySet())
    7676        {       
    77             pabloB.ast.FuncDefNode funcDefNode                  = entry.getValue();
    78             pabloB.ast.FuncDefNode finalFuncDefNode     = finalMap.get(entry.getKey());
     77            FuncDefNode funcDefNode                 = entry.getValue();
     78            FuncDefNode finalFuncDefNode            = finalMap.get(entry.getKey());
    7979
    8080            Locator locator = funcDefNode;
    8181
    82             IdentifierNode doBlockIdentifier = Generators.makeIdentifierNode(locator, DO_BLOCK);
     82            IdentifierNode doBlockIdentifier        = Generators.makeIdentifierNode(locator, DO_BLOCK);
    8383            funcDefNode.replaceChild(Accessors.funcIdentifier(funcDefNode), doBlockIdentifier);
    8484
    85             IdentifierNode doFinalBlockIdentifier = Generators.makeIdentifierNode(locator, DO_OPT_BLOCK);
     85            IdentifierNode doFinalBlockIdentifier   = Generators.makeIdentifierNode(locator, DO_OPT_BLOCK);
    8686            finalFuncDefNode.replaceChild(Accessors.funcIdentifier(finalFuncDefNode), doFinalBlockIdentifier);                 
    8787
     
    136136            stateDefNode.appendChild(property);
    137137
    138             pabloB.ast.KernelDefNode kernelDefNode =
     138            KernelDefNode kernelDefNode =
    139139                    Generators.makeKernelDef(kernelName,
    140140                            stateDefNode,
     
    174174     * Recursively builds function name to function definition node map via DFS.
    175175     */
    176     private static Map<String, pabloB.ast.FuncDefNode> makeFuncDefMap(pabloB.ast.ASTNode node) {
    177 
    178         if(node instanceof pabloB.ast.FuncDefNode) {
    179             Map<String, pabloB.ast.FuncDefNode> map = new HashMap<String, pabloB.ast.FuncDefNode>();
    180             String key = toolchain.pabloB.ast.Accessors.name((pabloB.ast.FuncDefNode)node);
    181             pabloB.ast.FuncDefNode value = (pabloB.ast.FuncDefNode)node;
     176    private static Map<String, FuncDefNode> makeFuncDefMap(ASTNode node) {
     177
     178        if(node instanceof FuncDefNode) {
     179            Map<String, FuncDefNode> map = new HashMap<String, FuncDefNode>();
     180            String key = toolchain.pabloB.ast.Accessors.name((FuncDefNode)node);
     181            FuncDefNode value = (FuncDefNode)node;
    182182            map.put(key, value);
    183183            return map;
    184184        }
    185185
    186         Map<String, pabloB.ast.FuncDefNode> map = new HashMap<String, pabloB.ast.FuncDefNode>();
    187 
    188         for(pabloB.ast.ASTNode child : node.getChildren()) {
     186        Map<String, FuncDefNode> map = new HashMap<String, FuncDefNode>();
     187
     188        for(ASTNode child : node.getChildren()) {
    189189            map.putAll(makeFuncDefMap(child));
    190190        }
     
    196196     * pabloS to pabloB node builder
    197197     */
    198     private static class ASTBuilder extends pabloS.ast.ASTVisitor.Default<pabloB.ast.ASTNode> {
    199 
     198    private static class ASTBuilder extends pabloS.ast.ASTVisitor.Default<ASTNode> {
     199
     200        private Map<pabloS.ast.ASTNode, PropertyInfoSet> infoSetMap;
    200201        private Context context;
    201202       
    202         ASTBuilder(boolean finalBlockMode) {
     203        ASTBuilder(Map<pabloS.ast.ASTNode, PropertyInfoSet> infoSetMap, boolean finalBlockMode) { // TODO - KH: reorganize this part, static interface, etc ...
     204           
     205            this.infoSetMap = infoSetMap;
     206           
    203207            context = new Context(builtinEncoder, carrySetEncoder, true, finalBlockMode, 0);
    204208        }
     
    206210        // General case.
    207211        @Override
    208         public pabloB.ast.ASTNode defaultVisitLeave(pabloS.ast.ASTNode node, List<pabloB.ast.ASTNode> childResults) {
     212        public ASTNode defaultVisitLeave(pabloS.ast.ASTNode node, List<ASTNode> childResults) {
    209213            Class<?> nodeClass = node.getClass();
    210214            String nodeName = nodeClass.getSimpleName();
     
    215219                Class<?> pabloBNodeClass = Class.forName(pabloBNodeName);
    216220                Constructor<?> constructor = pabloBNodeClass.getConstructor(pabloB.tokens.Token.class);
    217                 pabloB.ast.ASTNode pabloBNode = (pabloB.ast.ASTNode) constructor.newInstance(pabloBToken);
     221                ASTNode pabloBNode = (ASTNode) constructor.newInstance(pabloBToken);
    218222                appendChildResults(pabloBNode, childResults);
    219223                return pabloBNode;
     
    224228        }
    225229
    226         protected static void appendChildResults(pabloB.ast.ASTNode snode, List<pabloB.ast.ASTNode> childResults) {
    227             for(pabloB.ast.ASTNode child : childResults) {
     230        protected static void appendChildResults(ASTNode snode, List<ASTNode> childResults) {
     231            for(ASTNode child : childResults) {
    228232                snode.appendChild(child);
    229233            }
     
    238242        // TODO - KH: Handle field width attributes on PabloS stream types
    239243        //
    240         public pabloB.ast.ASTNode visitLeave(pabloS.ast.StreamTypeNode snode, List<pabloB.ast.ASTNode> childResults) {
     244        public ASTNode visitLeave(pabloS.ast.StreamTypeNode snode, List<ASTNode> childResults) {
    241245
    242246            String lexeme = pabloB.lexicalAnalyzer.Lextant.BITBLOCK.getPrimaryLexeme();
     
    246250                    pabloB.lexicalAnalyzer.Lextant.forLexeme(lexeme, Generators.LEXICAL_CONTEXT));     
    247251
    248             pabloB.ast.ASTNode replacement = new pabloB.ast.BitBlockTypeNode(bToken);
     252            ASTNode replacement = new BitBlockTypeNode(bToken);
    249253            appendChildResults(replacement, childResults);
    250254            return replacement;
     
    262266            } else {
    263267               
    264                 ASTNode replacment  = new FuncCallNode(Generators.makeToken(snode.getToken()));
    265                 appendChildResults(replacment, childResults);
    266                
    267                 return replacment;
    268             }
    269         }
    270 
    271 //        private ASTNode makeIdisaConstant(Locator locator, int fw, int value) {
    272 //           
    273 //            IntegerConstantNode valueNode = Generators.makeIntegerConstantNode(locator, value);
    274 //            FieldWidthNode fieldWidth = Generators.makeIdisaFieldWidthNode(locator, fw);
    275 //           
    276 //            ASTNode replacement = Generators.makeIdisaFuncCallNode(locator, SIMD_CONSTANT, fieldWidth, valueNode);
    277 //            return replacement;
    278 //        }
    279 
    280 
    281        
    282         /*       
    283         private ASTNode makeSIMDConstantCall(
    284                 String assert0CallName                  = builtinEncoder.getName(PabloSBuiltin.ASSERT_ZERO);
    285                 ASTNode errorStream          = childResults.get(1).deepCopy();
    286                 ASTNode errorMsg             = childResults.get(2).deepCopy();
    287 
    288                 ASTNode assert0Call          = Generators.makeFuncCallNode(locator,
    289                         assert0CallName,
    290                         errorStream,             
    291                         errorMsg);
    292 
    293                 BlockStmtNode blockStmt                 = Generators.makeBlockStmtNode(locator, assert0Call);
    294                 ASTNode replacement          = Generators.makeIfStmtNode(locator,
    295                         errorStream.deepCopy(),
    296                         blockStmt);
     268                ASTNode replacement  = new FuncCallNode(Generators.makeToken(snode.getToken()));
     269                appendChildResults(replacement, childResults);
     270               
    297271                return replacement;
    298         }*/
    299        
    300        
    301        
     272            }
     273        }
    302274
    303275        public ASTNode visitLeave(pabloS.ast.IntegerConstantNode snode, List<ASTNode> childResults) {
     
    309281        }
    310282
    311 
    312283        public ASTNode visitLeave(pabloS.ast.BinaryOperatorNode snode, List<ASTNode> childResults) {
    313284
     
    323294                ASTNode lhs = childResults.get(0);
    324295                ASTNode rhs = childResults.get(1);
    325                
     296
    326297                if(tokenS.isLextant(pabloS.lexicalAnalyzer.Lextant.OR)) {
    327298                    replacement = Generators.makeIdisaFuncCallNode(locator, SIMD_OR, BITBLOCK_SIZE, Generators.arguments(lhs, rhs));
     
    389360        }
    390361       
     362        public ASTNode visitLeave(pabloS.ast.AssignNode snode, List<ASTNode> childResults) {
     363       
     364            pabloS.ast.ASTNode rhs = toolchain.pabloS.ast.Accessors.rhs(snode);
     365           
     366            if(BuiltinCallUtil.isCarry(rhs)) {
     367               
     368               
     369               
     370                int carry1;
     371                //try {
     372                    System.out.println("Looking up...");
     373                    System.out.println(rhs);
     374                   
     375                    if(this.infoSetMap.containsKey(snode)) {
     376                   
     377                        //    System.out.println(snode);
     378                       
     379                    } else {
     380                       
     381                        System.out.println("NOT FOUND");
     382                       
     383                        System.out.println(snode);
     384                       
     385                    }
     386                   
     387                ASTNode replacement  = new AssignNode(Generators.makeToken(snode.getToken()));
     388                appendChildResults(replacement, childResults);
     389                return replacement;               
     390               
     391            } else {
     392                ASTNode replacement  = new AssignNode(Generators.makeToken(snode.getToken()));
     393                appendChildResults(replacement, childResults);
     394                return replacement;
     395            }
     396           
     397
     398           
     399        }
     400       
    391401    }   
    392402   
Note: See TracChangeset for help on using the changeset viewer.