Changeset 3381 for proto


Ignore:
Timestamp:
Jul 3, 2013, 3:13:33 PM (6 years ago)
Author:
ksherdy
Message:

Partial check in marked for reversion. Progress towards S->S, S->B, B->B translation organization.

Location:
proto/pabloj/trunk
Files:
3 edited

Legend:

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

    r3376 r3381  
    387387                        u8.badprefix = simd_or(temp68,temp71);
    388388                        u8_error = u8.badprefix;
    389                         u8.scope22 = pablo.Advance(u8.prefix2);
     389                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix2,carry_set_0.getCarry(0),u8.scope22));
    390390                        u8anyscope = u8.scope22;
    391391                        if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.carryRange(0,9))))
     
    411411                                u8.xBF = simd_and(temp73,temp23);
    412412                                u8.xBE = simd_and(temp73,temp15);
    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);
     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));
    418418                                BitBlock E0_F0_scope;
    419                                 E0_F0_scope = pablo.Advance(simd_or(xE0,xF0));
     419                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(simd_or(xE0,xF0),carry_set_0.getCarry(6),E0_F0_scope));
    420420                                BitBlock ED_F4_scope;
    421                                 ED_F4_scope = pablo.Advance(simd_or(xED,xF4));
     421                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(simd_or(xED,xF4),carry_set_0.getCarry(7),ED_F4_scope));
    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                                 u8.xEF_scope = pablo.Advance(xEF);
     426                                carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(xEF,carry_set_0.getCarry(8),u8.xEF_scope));
    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                                 EF_BF_pending = pablo.Advance(simd_and(u8.xEF_scope,u8.xBF));
     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));
    441441                                u8_FFFE_FFFF = simd_and(EF_BF_pending,simd_or(u8.xBE,u8.xBF));
    442442                        }
     
    654654                        u8.badprefix = simd_or(temp68,temp71);
    655655                        u8_error = u8.badprefix;
    656                         u8.scope22 = pablo.Advance(u8.prefix2);
     656                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix2,carry_set_0.getCarry(0),u8.scope22));
    657657                        u8anyscope = u8.scope22;
    658658                        if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.carryRange(0,9))))
     
    678678                                u8.xBF = simd_and(temp73,temp23);
    679679                                u8.xBE = simd_and(temp73,temp15);
    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);
     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));
    685685                                BitBlock E0_F0_scope;
    686                                 E0_F0_scope = pablo.Advance(simd_or(xE0,xF0));
     686                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(simd_or(xE0,xF0),carry_set_0.getCarry(6),E0_F0_scope));
    687687                                BitBlock ED_F4_scope;
    688                                 ED_F4_scope = pablo.Advance(simd_or(xED,xF4));
     688                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(simd_or(xED,xF4),carry_set_0.getCarry(7),ED_F4_scope));
    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                                 u8.xEF_scope = pablo.Advance(xEF);
     693                                carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(xEF,carry_set_0.getCarry(8),u8.xEF_scope));
    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                                 EF_BF_pending = pablo.Advance(simd_and(u8.xEF_scope,u8.xBF));
     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));
    708708                                u8_FFFE_FFFF = simd_and(EF_BF_pending,simd_or(u8.xBE,u8.xBF));
    709709                        }
     
    756756                w = simd_or(lex.Hyphen,lex.QMark);
    757757                BitBlock v1;
    758                 v1 = pablo.AdvanceN(v,1);
     758                carry_set_0.getPending64(0) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(v,1,carry_set_0.getPending64(0),v1));
    759759                BitBlock w1;
    760                 w1 = pablo.AdvanceN(w,1);
     760                carry_set_0.getPending64(1) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(w,1,carry_set_0.getPending64(1),w1));
    761761                BitBlock LAngle_scope;
    762762                LAngle_scope = simd_andc(v1,w1);
     
    775775                        BitBlock DoubleRBracket;
    776776                        BitBlock _temp0;
    777                         _temp0 = pablo.Advance(lex.RBracket);
     777                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(lex.RBracket,carry_set_0.getCarry(0),_temp0));
    778778                        DoubleRBracket = simd_and(_temp0,lex.RBracket);
    779779                        BitBlock _temp1;
    780                         _temp1 = pablo.Advance(DoubleRBracket);
     780                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(DoubleRBracket,carry_set_0.getCarry(1),_temp1));
    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                 CtCDPI_Cursor = pablo.ScanToFirst(CtCDPI_opener);
     790                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanToFirst(CtCDPI_opener,carry_set_0.getCarry(2),CtCDPI_Cursor));
    791791                if (bitblock::any(simd_or(CtCDPI_Cursor,carry_set_0.carryRange(0,13))))
    792792                {
     
    795795                        PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    796796                        BitBlock CD_Ct_Cursor;
    797                         CD_Ct_Cursor = pablo.Advance(simd_andc(CtCDPI_Cursor,PI_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));
    798798                        BitBlock CD_Cursor;
    799799                        CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
     
    803803                        {
    804804                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
    805                                 PI_Cursor = pablo.Advance(PI_Cursor);
     805                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_0.getCarry(4),PI_Cursor));
    806806                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    807807                                BitBlock PI_name_end;
    808                                 PI_name_end = pablo.ScanThru(PI_Cursor,lex.NameScan);
     808                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_0.getCarry(5),PI_name_end));
    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                                 _temp2 = pablo.Advance(PI_noWS);
     814                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_0.getCarry(6),_temp2));
    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                                 PI_Cursor = pablo.ScanTo(PI_name_end,PI_closer);
     821                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,PI_closer,carry_set_0.getCarry(7),PI_Cursor));
    822822                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    823823                                CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     
    830830                        {
    831831                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    832                                 CD_Cursor = pablo.ScanTo(CD_Cursor,CD_closer);
     832                                carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,CD_closer,carry_set_0.getCarry(8),CD_Cursor));
    833833                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    834834                                CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     
    841841                        {
    842842                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
    843                                 Ct_Cursor = pablo.Advance(Ct_Cursor);
     843                                carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(9),Ct_Cursor));
    844844                                BitBlock Ct_error;
    845845                                Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    846846                                BitBlock _temp3;
    847                                 _temp3 = pablo.Advance(Ct_Cursor);
    848                                 Ct_Cursor = pablo.Advance(_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));
    849849                                BitBlock _temp4;
    850                                 _temp4 = pablo.ScanTo(Ct_Cursor,DoubleHyphen);
    851                                 Ct_Cursor = pablo.Advance(_temp4);
     850                                carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,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));
    852852                                if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    853853                                {
     
    862862                        }
    863863                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
    864                         ctCDPI_mask = pablo.InclusiveSpan(CtCDPI_starts,CtCDPI_ends);
     864                        carry_set_0.getCarry(14) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_0.getCarry(14),ctCDPI_mask));
    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                         CtCDPI_Cursor = pablo.ScanTo(CtCDPI_Cursor,CtCDPI_opener);
     869                        carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,CtCDPI_opener,carry_set_0.getCarry(15),CtCDPI_Cursor));
    870870                        while (bitblock::any(CtCDPI_Cursor))
    871871                        {
     
    875875                                PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    876876                                BitBlock CD_Ct_Cursor;
    877                                 CD_Ct_Cursor = pablo.Advance(simd_andc(CtCDPI_Cursor,PI_Cursor));
     877                                carry_set_0.getCarry(16) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.getCarry(16),CD_Ct_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                                         PI_Cursor = pablo.Advance(PI_Cursor);
     885                                        carry_set_0.getCarry(17) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_0.getCarry(17),PI_Cursor));
    886886                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    887887                                        BitBlock PI_name_end;
    888                                         PI_name_end = pablo.ScanThru(PI_Cursor,lex.NameScan);
     888                                        carry_set_0.getCarry(18) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_0.getCarry(18),PI_name_end));
    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                                         _temp2 = pablo.Advance(PI_noWS);
     894                                        carry_set_0.getCarry(19) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_0.getCarry(19),_temp2));
    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                                         PI_Cursor = pablo.ScanTo(PI_name_end,PI_closer);
     901                                        carry_set_0.getCarry(20) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,PI_closer,carry_set_0.getCarry(20),PI_Cursor));
    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                                         CD_Cursor = pablo.ScanTo(CD_Cursor,CD_closer);
     908                                        carry_set_0.getCarry(21) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,CD_closer,carry_set_0.getCarry(21),CD_Cursor));
    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                                         Ct_Cursor = pablo.Advance(Ct_Cursor);
     915                                        carry_set_0.getCarry(22) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(22),Ct_Cursor));
    916916                                        BitBlock Ct_error;
    917917                                        Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    918918                                        BitBlock _temp3;
    919                                         _temp3 = pablo.Advance(Ct_Cursor);
    920                                         Ct_Cursor = pablo.Advance(_temp3);
     919                                        carry_set_0.getCarry(23) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(23),_temp3));
     920                                        carry_set_0.getCarry(24) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_0.getCarry(24),Ct_Cursor));
    921921                                        BitBlock _temp4;
    922                                         _temp4 = pablo.ScanTo(Ct_Cursor,DoubleHyphen);
    923                                         Ct_Cursor = pablo.Advance(_temp4);
     922                                        carry_set_0.getCarry(25) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,DoubleHyphen,carry_set_0.getCarry(25),_temp4));
     923                                        carry_set_0.getCarry(26) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_0.getCarry(26),Ct_Cursor));
    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                                 ctCDPI_mask = pablo.InclusiveSpan(CtCDPI_starts,CtCDPI_ends);
     932                                carry_set_0.getCarry(27) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_0.getCarry(27),ctCDPI_mask));
    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                                 CtCDPI_Cursor = pablo.ScanTo(CtCDPI_Cursor,CtCDPI_opener);
     937                                carry_set_0.getCarry(28) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,CtCDPI_opener,carry_set_0.getCarry(28),CtCDPI_Cursor));
    938938                                LocalCarryCombine(carry_set_0,carry_set_1,0,13);
    939939                        }
     
    944944                }
    945945                BitBlock _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));
     946                carry_set_0.getCarry(29) = 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(29),_temp5));
    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                 v1 = pablo.AdvanceN(v,1);
     975                carry_set_0.getPending64(0) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(v,1,carry_set_0.getPending64(0),v1));
    976976                BitBlock w1;
    977                 w1 = pablo.AdvanceN(w,1);
     977                carry_set_0.getPending64(1) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(w,1,carry_set_0.getPending64(1),w1));
    978978                BitBlock LAngle_scope;
    979979                LAngle_scope = simd_andc(v1,w1);
     
    992992                        BitBlock DoubleRBracket;
    993993                        BitBlock _temp0;
    994                         _temp0 = pablo.Advance(lex.RBracket);
     994                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(lex.RBracket,carry_set_0.getCarry(0),_temp0));
    995995                        DoubleRBracket = simd_and(_temp0,lex.RBracket);
    996996                        BitBlock _temp1;
    997                         _temp1 = pablo.Advance(DoubleRBracket);
     997                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(DoubleRBracket,carry_set_0.getCarry(1),_temp1));
    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                 CtCDPI_Cursor = pablo.ScanToFirst(CtCDPI_opener);
     1007                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanToFirst(CtCDPI_opener,carry_set_0.getCarry(2),CtCDPI_Cursor));
    10081008                if (bitblock::any(simd_or(simd_and(CtCDPI_Cursor,EOF_mask),carry_set_0.carryRange(0,13))))
    10091009                {
     
    10121012                        PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    10131013                        BitBlock CD_Ct_Cursor;
    1014                         CD_Ct_Cursor = pablo.Advance(simd_andc(CtCDPI_Cursor,PI_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));
    10151015                        BitBlock CD_Cursor;
    10161016                        CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
     
    10201020                        {
    10211021                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
    1022                                 PI_Cursor = pablo.Advance(PI_Cursor);
     1022                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_0.getCarry(4),PI_Cursor));
    10231023                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    10241024                                BitBlock PI_name_end;
    1025                                 PI_name_end = pablo.ScanThru(PI_Cursor,lex.NameScan);
     1025                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_0.getCarry(5),PI_name_end));
    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                                 _temp2 = pablo.Advance(PI_noWS);
     1031                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_0.getCarry(6),_temp2));
    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                                 PI_Cursor = pablo.ScanTo(PI_name_end,PI_closer);
     1038                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,PI_closer,carry_set_0.getCarry(7),PI_Cursor));
    10391039                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    10401040                                CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     
    10471047                        {
    10481048                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    1049                                 CD_Cursor = pablo.ScanTo(CD_Cursor,CD_closer);
     1049                                carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,CD_closer,carry_set_0.getCarry(8),CD_Cursor));
    10501050                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    10511051                                CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     
    10581058                        {
    10591059                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
    1060                                 Ct_Cursor = pablo.Advance(Ct_Cursor);
     1060                                carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(9),Ct_Cursor));
    10611061                                BitBlock Ct_error;
    10621062                                Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    10631063                                BitBlock _temp3;
    1064                                 _temp3 = pablo.Advance(Ct_Cursor);
    1065                                 Ct_Cursor = pablo.Advance(_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));
    10661066                                BitBlock _temp4;
    1067                                 _temp4 = pablo.ScanTo(Ct_Cursor,DoubleHyphen);
    1068                                 Ct_Cursor = pablo.Advance(_temp4);
     1067                                carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,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));
    10691069                                if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    10701070                                {
     
    10791079                        }
    10801080                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
    1081                         ctCDPI_mask = pablo.InclusiveSpan(CtCDPI_starts,CtCDPI_ends);
     1081                        carry_set_0.getCarry(14) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_0.getCarry(14),ctCDPI_mask));
    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                         CtCDPI_Cursor = pablo.ScanTo(CtCDPI_Cursor,CtCDPI_opener);
     1086                        carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,CtCDPI_opener,carry_set_0.getCarry(15),CtCDPI_Cursor));
    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                                 CD_Ct_Cursor = pablo.Advance(simd_andc(CtCDPI_Cursor,PI_Cursor));
     1094                                carry_set_0.getCarry(16) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.getCarry(16),CD_Ct_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                                         PI_Cursor = pablo.Advance(PI_Cursor);
     1102                                        carry_set_0.getCarry(17) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_0.getCarry(17),PI_Cursor));
    11031103                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    11041104                                        BitBlock PI_name_end;
    1105                                         PI_name_end = pablo.ScanThru(PI_Cursor,lex.NameScan);
     1105                                        carry_set_0.getCarry(18) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_0.getCarry(18),PI_name_end));
    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                                         _temp2 = pablo.Advance(PI_noWS);
     1111                                        carry_set_0.getCarry(19) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_0.getCarry(19),_temp2));
    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                                         PI_Cursor = pablo.ScanTo(PI_name_end,PI_closer);
     1118                                        carry_set_0.getCarry(20) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,PI_closer,carry_set_0.getCarry(20),PI_Cursor));
    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                                         CD_Cursor = pablo.ScanTo(CD_Cursor,CD_closer);
     1125                                        carry_set_0.getCarry(21) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,CD_closer,carry_set_0.getCarry(21),CD_Cursor));
    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                                         Ct_Cursor = pablo.Advance(Ct_Cursor);
     1132                                        carry_set_0.getCarry(22) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(22),Ct_Cursor));
    11331133                                        BitBlock Ct_error;
    11341134                                        Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    11351135                                        BitBlock _temp3;
    1136                                         _temp3 = pablo.Advance(Ct_Cursor);
    1137                                         Ct_Cursor = pablo.Advance(_temp3);
     1136                                        carry_set_0.getCarry(23) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(23),_temp3));
     1137                                        carry_set_0.getCarry(24) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_0.getCarry(24),Ct_Cursor));
    11381138                                        BitBlock _temp4;
    1139                                         _temp4 = pablo.ScanTo(Ct_Cursor,DoubleHyphen);
    1140                                         Ct_Cursor = pablo.Advance(_temp4);
     1139                                        carry_set_0.getCarry(25) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,DoubleHyphen,carry_set_0.getCarry(25),_temp4));
     1140                                        carry_set_0.getCarry(26) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_0.getCarry(26),Ct_Cursor));
    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                                 ctCDPI_mask = pablo.InclusiveSpan(CtCDPI_starts,CtCDPI_ends);
     1149                                carry_set_0.getCarry(27) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_0.getCarry(27),ctCDPI_mask));
    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                                 CtCDPI_Cursor = pablo.ScanTo(CtCDPI_Cursor,CtCDPI_opener);
     1154                                carry_set_0.getCarry(28) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,CtCDPI_opener,carry_set_0.getCarry(28),CtCDPI_Cursor));
    11551155                                LocalCarryCombine(carry_set_0,carry_set_1,0,13);
    11561156                        }
     
    11611161                }
    11621162                BitBlock _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));
     1163                carry_set_0.getCarry(29) = 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(29),_temp5));
    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                 tag_Callouts.ElemName_ends = pablo.ScanThru(tag_Callouts.ElemName_starts,lex.NameScan);
     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));
    11941194                BitBlock ParseError;
    11951195                ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
     
    12011201                {
    12021202                        BitBlock AfterWS;
    1203                         AfterWS = pablo.ScanThru(tag_Callouts.ElemName_ends,lex.WS);
     1203                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_ends,lex.WS,carry_set_0.getCarry(1),AfterWS));
    12041204                        AttListEnd = simd_and(AfterWS,AttListDelim);
    12051205                        BitBlock AttNameStart;
     
    12101210                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
    12111211                                BitBlock AttNameFollow;
    1212                                 AttNameFollow = pablo.ScanThru(AttNameStart,lex.NameScan);
     1212                                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_0.getCarry(2),AttNameFollow));
    12131213                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
    12141214                                if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.carryRange(0,1))))
    12151215                                {
    1216                                         EqExpected = pablo.ScanThru(AttNameFollow,lex.WS);
     1216                                        carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_0.getCarry(3),EqExpected));
    12171217                                }
    12181218                                else
     
    12231223                                ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
    12241224                                BitBlock AttValPos;
    1225                                 AttValPos = pablo.AdvanceThenScanThru(EqExpected,lex.WS);
     1225                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_0.getCarry(4),AttValPos));
    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                                 DQuoteAttEnd = pablo.AdvanceThenScanTo(DQuoteAttVal,DQuoteDelim);
     1232                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,DQuoteDelim,carry_set_0.getCarry(5),DQuoteAttEnd));
    12331233                                BitBlock SQuoteAttEnd;
    1234                                 SQuoteAttEnd = pablo.AdvanceThenScanTo(SQuoteAttVal,SQuoteDelim);
     1234                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,SQuoteDelim,carry_set_0.getCarry(6),SQuoteAttEnd));
    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                                 AttValFollow = pablo.Advance(AttValEnd);
     1239                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(7),AttValFollow));
    12401240                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
    12411241                                if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.carryRange(0,1))))
    12421242                                {
    1243                                         AfterWS = pablo.ScanThru(AttValFollow,lex.WS);
     1243                                        carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_0.getCarry(8),AfterWS));
    12441244                                        AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
    12451245                                        AttNameStart = simd_andc(AfterWS,AttListDelim);
     
    12581258                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
    12591259                                        BitBlock AttNameFollow;
    1260                                         AttNameFollow = pablo.ScanThru(AttNameStart,lex.NameScan);
     1260                                        carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_0.getCarry(9),AttNameFollow));
    12611261                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
    12621262                                        if (bitblock::any(simd_and(AttNameFollow,lex.WS)))
    12631263                                        {
    1264                                                 EqExpected = pablo.ScanThru(AttNameFollow,lex.WS);
     1264                                                carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_0.getCarry(10),EqExpected));
    12651265                                        }
    12661266                                        else
     
    12701270                                        ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
    12711271                                        BitBlock AttValPos;
    1272                                         AttValPos = pablo.AdvanceThenScanThru(EqExpected,lex.WS);
     1272                                        carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_0.getCarry(11),AttValPos));
    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                                         DQuoteAttEnd = pablo.AdvanceThenScanTo(DQuoteAttVal,DQuoteDelim);
     1279                                        carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,DQuoteDelim,carry_set_0.getCarry(12),DQuoteAttEnd));
    12801280                                        BitBlock SQuoteAttEnd;
    1281                                         SQuoteAttEnd = pablo.AdvanceThenScanTo(SQuoteAttVal,SQuoteDelim);
     1281                                        carry_set_0.getCarry(13) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,SQuoteDelim,carry_set_0.getCarry(13),SQuoteAttEnd));
    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                                         AttValFollow = pablo.Advance(AttValEnd);
     1286                                        carry_set_0.getCarry(14) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(14),AttValFollow));
    12871287                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
    12881288                                        if (bitblock::any(simd_and(AttValFollow,lex.WS)))
    12891289                                        {
    1290                                                 AfterWS = pablo.ScanThru(AttValFollow,lex.WS);
     1290                                                carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_0.getCarry(15),AfterWS));
    12911291                                                AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
    12921292                                                AttNameStart = simd_andc(AfterWS,AttListDelim);
     
    13141314                BitBlock STagEnds;
    13151315                STagEnds = simd_and(AttListEnd,lex.RAngle);
    1316                 tag_Callouts.EmptyTag_marks = pablo.Advance(simd_and(AttListEnd,lex.Slash));
     1316                carry_set_0.getCarry(16) = bitblock::srli<127>(pablo_blk_Advance(simd_and(AttListEnd,lex.Slash),carry_set_0.getCarry(16),tag_Callouts.EmptyTag_marks));
    13171317                ParseError = simd_or(ParseError,simd_andc(tag_Callouts.EmptyTag_marks,lex.RAngle));
    13181318                BitBlock EndTagEnds;
    1319                 EndTagEnds = pablo.AdvanceThenScanThru(tag_Callouts.EndTag_marks,lex.NameScan);
     1319                carry_set_0.getCarry(17) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.getCarry(17),EndTagEnds));
    13201320                if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.carryRange(0,1))))
    13211321                {
    1322                         EndTagEnds = pablo.ScanThru(EndTagEnds,lex.WS);
     1322                        carry_set_0.getCarry(18) = bitblock::srli<127>(pablo_blk_ScanThru(EndTagEnds,lex.WS,carry_set_0.getCarry(18),EndTagEnds));
    13231323                }
    13241324                else
     
    13311331                        assert_0_error(ParseError,"Tag parsing error found");
    13321332                }
    1333                 tag_Callouts.AttVal_spans = pablo.SpanUpTo(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends);
     1333                carry_set_0.getCarry(19) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends,carry_set_0.getCarry(19),tag_Callouts.AttVal_spans));
    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                 tag_Callouts.ElemName_ends = pablo.ScanThru(tag_Callouts.ElemName_starts,lex.NameScan);
     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));
    13521352                BitBlock ParseError;
    13531353                ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
     
    13591359                {
    13601360                        BitBlock AfterWS;
    1361                         AfterWS = pablo.ScanThru(tag_Callouts.ElemName_ends,lex.WS);
     1361                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_ends,lex.WS,carry_set_0.getCarry(1),AfterWS));
    13621362                        AttListEnd = simd_and(AfterWS,AttListDelim);
    13631363                        BitBlock AttNameStart;
     
    13681368                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
    13691369                                BitBlock AttNameFollow;
    1370                                 AttNameFollow = pablo.ScanThru(AttNameStart,lex.NameScan);
     1370                                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_0.getCarry(2),AttNameFollow));
    13711371                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
    13721372                                if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.carryRange(0,1))))
    13731373                                {
    1374                                         EqExpected = pablo.ScanThru(AttNameFollow,lex.WS);
     1374                                        carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_0.getCarry(3),EqExpected));
    13751375                                }
    13761376                                else
     
    13811381                                ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
    13821382                                BitBlock AttValPos;
    1383                                 AttValPos = pablo.AdvanceThenScanThru(EqExpected,lex.WS);
     1383                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_0.getCarry(4),AttValPos));
    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                                 DQuoteAttEnd = pablo.AdvanceThenScanTo(DQuoteAttVal,DQuoteDelim);
     1390                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,DQuoteDelim,carry_set_0.getCarry(5),DQuoteAttEnd));
    13911391                                BitBlock SQuoteAttEnd;
    1392                                 SQuoteAttEnd = pablo.AdvanceThenScanTo(SQuoteAttVal,SQuoteDelim);
     1392                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,SQuoteDelim,carry_set_0.getCarry(6),SQuoteAttEnd));
    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                                 AttValFollow = pablo.Advance(AttValEnd);
     1397                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(7),AttValFollow));
    13981398                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
    13991399                                if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.carryRange(0,1))))
    14001400                                {
    1401                                         AfterWS = pablo.ScanThru(AttValFollow,lex.WS);
     1401                                        carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_0.getCarry(8),AfterWS));
    14021402                                        AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
    14031403                                        AttNameStart = simd_andc(AfterWS,AttListDelim);
     
    14161416                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
    14171417                                        BitBlock AttNameFollow;
    1418                                         AttNameFollow = pablo.ScanThru(AttNameStart,lex.NameScan);
     1418                                        carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_0.getCarry(9),AttNameFollow));
    14191419                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
    14201420                                        if (bitblock::any(simd_and(AttNameFollow,lex.WS)))
    14211421                                        {
    1422                                                 EqExpected = pablo.ScanThru(AttNameFollow,lex.WS);
     1422                                                carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_0.getCarry(10),EqExpected));
    14231423                                        }
    14241424                                        else
     
    14281428                                        ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
    14291429                                        BitBlock AttValPos;
    1430                                         AttValPos = pablo.AdvanceThenScanThru(EqExpected,lex.WS);
     1430                                        carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_0.getCarry(11),AttValPos));
    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                                         DQuoteAttEnd = pablo.AdvanceThenScanTo(DQuoteAttVal,DQuoteDelim);
     1437                                        carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,DQuoteDelim,carry_set_0.getCarry(12),DQuoteAttEnd));
    14381438                                        BitBlock SQuoteAttEnd;
    1439                                         SQuoteAttEnd = pablo.AdvanceThenScanTo(SQuoteAttVal,SQuoteDelim);
     1439                                        carry_set_0.getCarry(13) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,SQuoteDelim,carry_set_0.getCarry(13),SQuoteAttEnd));
    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                                         AttValFollow = pablo.Advance(AttValEnd);
     1444                                        carry_set_0.getCarry(14) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(14),AttValFollow));
    14451445                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
    14461446                                        if (bitblock::any(simd_and(AttValFollow,lex.WS)))
    14471447                                        {
    1448                                                 AfterWS = pablo.ScanThru(AttValFollow,lex.WS);
     1448                                                carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_0.getCarry(15),AfterWS));
    14491449                                                AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
    14501450                                                AttNameStart = simd_andc(AfterWS,AttListDelim);
     
    14721472                BitBlock STagEnds;
    14731473                STagEnds = simd_and(AttListEnd,lex.RAngle);
    1474                 tag_Callouts.EmptyTag_marks = pablo.Advance(simd_and(AttListEnd,lex.Slash));
     1474                carry_set_0.getCarry(16) = bitblock::srli<127>(pablo_blk_Advance(simd_and(AttListEnd,lex.Slash),carry_set_0.getCarry(16),tag_Callouts.EmptyTag_marks));
    14751475                ParseError = simd_or(ParseError,simd_andc(tag_Callouts.EmptyTag_marks,lex.RAngle));
    14761476                BitBlock EndTagEnds;
    1477                 EndTagEnds = pablo.AdvanceThenScanThru(tag_Callouts.EndTag_marks,lex.NameScan);
     1477                carry_set_0.getCarry(17) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.getCarry(17),EndTagEnds));
    14781478                if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.carryRange(0,1))))
    14791479                {
    1480                         EndTagEnds = pablo.ScanThru(EndTagEnds,lex.WS);
     1480                        carry_set_0.getCarry(18) = bitblock::srli<127>(pablo_blk_ScanThru(EndTagEnds,lex.WS,carry_set_0.getCarry(18),EndTagEnds));
    14811481                }
    14821482                else
     
    14891489                        assert_0_error(ParseError,"Tag parsing error found");
    14901490                }
    1491                 tag_Callouts.AttVal_spans = pablo.SpanUpTo(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends);
     1491                carry_set_0.getCarry(19) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends,carry_set_0.getCarry(19),tag_Callouts.AttVal_spans));
    14921492        }
    14931493       
     
    15141514                {
    15151515                        BitBlock Ref_scope;
    1516                         Ref_scope = pablo.Advance(marker.Ref_opener);
     1516                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(marker.Ref_opener,carry_set_0.getCarry(0),Ref_scope));
    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                         NumRef3 = pablo.Advance(NumRef2);
     1521                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(NumRef2,carry_set_0.getCarry(1),NumRef3));
    15221522                        BitBlock HexRef3;
    15231523                        HexRef3 = simd_and(NumRef3,lex.x);
    15241524                        ref_Callouts.DecRef_starts = simd_andc(NumRef3,lex.x);
    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);
     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));
    15291529                        BitBlock ref_error1;
    15301530                        ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
     
    15601560                {
    15611561                        BitBlock Ref_scope;
    1562                         Ref_scope = pablo.Advance(marker.Ref_opener);
     1562                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(marker.Ref_opener,carry_set_0.getCarry(0),Ref_scope));
    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                         NumRef3 = pablo.Advance(NumRef2);
     1567                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(NumRef2,carry_set_0.getCarry(1),NumRef3));
    15681568                        BitBlock HexRef3;
    15691569                        HexRef3 = simd_and(NumRef3,lex.x);
    15701570                        ref_Callouts.DecRef_starts = simd_andc(NumRef3,lex.x);
    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);
     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));
    15751575                        BitBlock ref_error1;
    15761576                        ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
     
    16041604        {
    16051605                BitBlock PI_names;
    1606                 PI_names = pablo.SpanUpTo(ctCDPI_Callouts.PI_name_starts,ctCDPI_Callouts.PI_name_ends);
     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));
    16071607                BitBlock GenRefs;
    1608                 GenRefs = pablo.SpanUpTo(ref_Callouts.GenRef_starts,ref_Callouts.GenRef_ends);
     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));
    16091609                BitBlock ElemNames;
    1610                 ElemNames = pablo.SpanUpTo(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
     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));
    16111611                BitBlock AttNames;
    1612                 AttNames = pablo.SpanUpTo(tag_Callouts.AttName_starts,tag_Callouts.AttName_ends);
     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));
    16131613                BitBlock qname_stream;
    16141614                qname_stream = simd_or(ElemNames,AttNames);
     
    16191619                BitBlock name_start;
    16201620                BitBlock _temp0;
    1621                 _temp0 = pablo.Advance(name_stream);
     1621                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(4),_temp0));
    16221622                name_start = simd_andc(name_stream,_temp0);
    16231623                BitBlock name_cursor;
    16241624                BitBlock _temp1;
    1625                 _temp1 = pablo.Advance(name_stream);
     1625                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(5),_temp1));
    16261626                name_cursor = simd_andc(name_stream,_temp1);
    16271627                BitBlock void_prefix_err;
     
    16291629                BitBlock namespace_sep;
    16301630                BitBlock _temp2;
    1631                 _temp2 = pablo.ScanThru(name_cursor,simd_andc(lex.NameScan,lex.Colon));
     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));
    16321632                namespace_sep = simd_and(_temp2,lex.Colon);
    16331633                BitBlock local_part_start;
    1634                 local_part_start = pablo.Advance(namespace_sep);
     1634                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(namespace_sep,carry_set_0.getCarry(7),local_part_start));
    16351635                BitBlock local_part_err;
    16361636                local_part_err = simd_andc(local_part_start,lex.NameScan);
    16371637                BitBlock colon2_err;
    16381638                BitBlock _temp3;
    1639                 _temp3 = pablo.ScanThru(local_part_start,simd_andc(lex.NameScan,lex.Colon));
     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));
    16401640                colon2_err = simd_and(_temp3,lex.Colon);
    16411641                BitBlock ncname_err;
     
    16531653        {
    16541654                BitBlock PI_names;
    1655                 PI_names = pablo.SpanUpTo(ctCDPI_Callouts.PI_name_starts,ctCDPI_Callouts.PI_name_ends);
     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));
    16561656                BitBlock GenRefs;
    1657                 GenRefs = pablo.SpanUpTo(ref_Callouts.GenRef_starts,ref_Callouts.GenRef_ends);
     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));
    16581658                BitBlock ElemNames;
    1659                 ElemNames = pablo.SpanUpTo(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
     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));
    16601660                BitBlock AttNames;
    1661                 AttNames = pablo.SpanUpTo(tag_Callouts.AttName_starts,tag_Callouts.AttName_ends);
     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));
    16621662                BitBlock qname_stream;
    16631663                qname_stream = simd_or(ElemNames,AttNames);
     
    16681668                BitBlock name_start;
    16691669                BitBlock _temp0;
    1670                 _temp0 = pablo.Advance(name_stream);
     1670                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(4),_temp0));
    16711671                name_start = simd_andc(name_stream,_temp0);
    16721672                BitBlock name_cursor;
    16731673                BitBlock _temp1;
    1674                 _temp1 = pablo.Advance(name_stream);
     1674                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(5),_temp1));
    16751675                name_cursor = simd_andc(name_stream,_temp1);
    16761676                BitBlock void_prefix_err;
     
    16781678                BitBlock namespace_sep;
    16791679                BitBlock _temp2;
    1680                 _temp2 = pablo.ScanThru(name_cursor,simd_andc(lex.NameScan,lex.Colon));
     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));
    16811681                namespace_sep = simd_and(_temp2,lex.Colon);
    16821682                BitBlock local_part_start;
    1683                 local_part_start = pablo.Advance(namespace_sep);
     1683                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(namespace_sep,carry_set_0.getCarry(7),local_part_start));
    16841684                BitBlock local_part_err;
    16851685                local_part_err = simd_andc(local_part_start,lex.NameScan);
    16861686                BitBlock colon2_err;
    16871687                BitBlock _temp3;
    1688                 _temp3 = pablo.ScanThru(local_part_start,simd_andc(lex.NameScan,lex.Colon));
     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));
    16891689                colon2_err = simd_and(_temp3,lex.Colon);
    16901690                BitBlock ncname_err;
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltinTranslator.java

    r3380 r3381  
    4040            ASTNode getCarryCall = Generators.makeGetCarryCall(locator, carry1Position, context);
    4141            ASTNode returnValue = childResults.get(0);
    42             ASTNode[] pabloBlkFuncCallArgs = makePabloBlkArgs(locator, childResults, getCarryCall, returnValue);
     42            ASTNode[] pabloBlkFuncCallArgs = listAsArray(locator, childResults, getCarryCall, returnValue);
    4343           
    4444            ASTNode pabloBlkFuncCall = Generators.makeFuncCallNode(locator, pabloBlkCallFuncName, pabloBlkFuncCallArgs);
     
    6262            ASTNode getCarryCall = Generators.makePending64Call(locator, carryNPosition, context);
    6363            ASTNode returnValue = childResults.get(0);
    64             ASTNode[] pabloBlkFuncCallArgs = makePabloBlkArgs(locator, removeAdvanceNConstantArg(childResults), getCarryCall, returnValue);
     64           
     65            List<ASTNode> pabloBlkArgs = new ArrayList();
     66            //
     67            //
     68            //
     69            //
     70            //
     71            ASTNode[] pabloBlkFuncCallArgs = listFromArray(locator, removeAdvanceNConstantArg(childResults), getCarryCall, returnValue);
    6572           
    6673            ASTNode pabloBlkFuncCall = Generators.makeFuncCallNode(locator, pabloBlkCallFuncName, pabloBlkFuncCallArgs);
     
    7279        private List<ASTNode> removeAdvanceNConstantArg(List<ASTNode> childResults) {
    7380                List<ASTNode> args = new ArrayList<ASTNode>();
    74                 for(int i=0; i<childResults.size(); i++) {
     81                for(int i=1; i<childResults.size(); i++) {
    7582                        args.add(childResults.get(i));
    7683                }
     
    209216        }
    210217       
    211         private static ASTNode[] makePabloBlkArgs(Locator locator,
    212             List<ASTNode> childResults, ASTNode getCarryCallForBuiltin, ASTNode returnValue) {
    213         FuncCallArgListNode funcCallArgList    = (FuncCallArgListNode)childResults.get(1).child(1);
    214         List<ASTNode> args = funcCallArgList.getChildren();
    215         args.add(getCarryCallForBuiltin);
    216         args.add(returnValue);
    217        
    218         ASTNode argsAsArray [] = args.toArray(new ASTNode [args.size()]);
    219         return argsAsArray;
     218        private static ASTNode[] listFromArray(List<ASTNode> list) {
     219        return list.toArray(new ASTNode [list.size()]);
    220220    }
    221221
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/pabloS2PabloB/PabloS2PabloBXFormer.java

    r3380 r3381  
    366366                if(BuiltinCallUtil.isCarry(rhs)) {
    367367
     368                    Locator locator = Generators.makeToken(snode.getToken());
     369                   
    368370                        int carryPosition = 0;
     371                        ASTNode carryCall = null;
    369372
    370373                        if(BuiltinCallUtil.isCarry1(rhs)) {
    371                                 try {
    372                                                 carryPosition = infoSetMap.get(rhs).carry1Position();
    373                                         } catch (Exception e) {
    374                                                 //System.out.println(rhs);
    375                                         }
     374
     375                                        carryPosition = infoSetMap.get(rhs).carry1Position();
     376                                        carryCall = Generators.makeGetCarryCall(locator, carryPosition, context);
     377
    376378                        } else if(BuiltinCallUtil.isCarryN(rhs)) {
    377379                               
    378                                 if(!infoSetMap.containsKey(rhs)) {
    379                                         System.out.println("Not found.");
    380                                 } else {
    381                                         System.out.println("Found.");
    382                                 }
    383                                 //try {
    384                                                 carryPosition = infoSetMap.get(rhs).carryNPosition();
    385                                         //} catch (Exception e) {
    386                                                
    387                                                 System.out.println(carryPosition);
    388                                                
    389                                                 System.out.println("N");
    390                                                 System.out.println(rhs);
    391                                         //}
     380                                        carryPosition = infoSetMap.get(rhs).carryNPosition();
     381                                        carryCall = Generators.makePending64Call(locator, carryPosition, context);
    392382                        }
    393 
    394                         Locator locator = Generators.makeToken(snode.getToken());
     383                       
    395384                        ASTNode getCarryCall = Generators.makeGetCarryCall(locator, carryPosition, context);
    396385                        ASTNode lhs = childResults.get(0);
     
    401390                        ASTNode pabloBlkFuncCall = translator.translate(builtin, (pabloS.ast.FuncCallNode) rhs, context, childResults, carryPosition);
    402391
    403                         ASTNode replacement = Generators.makeAssignNode(locator, getCarryCall, pabloBlkFuncCall);
     392                        ASTNode replacement = Generators.makeAssignNode(locator, carryCall, pabloBlkFuncCall);
    404393
    405394                        return replacement;
Note: See TracChangeset for help on using the changeset viewer.