Ignore:
Timestamp:
Jul 5, 2013, 6:39:01 PM (6 years ago)
Author:
ksherdy
Message:

PabloS to PabloB translation. 'while' translation and code clean up remains.

File:
1 edited

Legend:

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

    r3385 r3387  
    389389                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix2,carry_set_0.getCarry(0),u8.scope22));
    390390                        u8anyscope = u8.scope22;
    391                         if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.carryRange(0,9))))
     391                        if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.carryRange(1,9))))
    392392                        {
    393393                                BitBlock xE0;
     
    443443                        else
    444444                        {
    445                                 carry_set_0.carryDequeueEnqueue(0,9);
     445                                carry_set_0.carryDequeueEnqueue(1,9);
    446446                        }
    447447                        BitBlock u8mismatch;
     
    656656                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix2,carry_set_0.getCarry(0),u8.scope22));
    657657                        u8anyscope = u8.scope22;
    658                         if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.carryRange(0,9))))
     658                        if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.carryRange(1,9))))
    659659                        {
    660660                                BitBlock xE0;
     
    710710                        else
    711711                        {
    712                                 carry_set_0.carryDequeueEnqueue(0,9);
     712                                carry_set_0.carryDequeueEnqueue(1,9);
    713713                        }
    714714                        BitBlock u8mismatch;
     
    732732        Parse_CtCDPI()
    733733        {
    734                 carry_set_0.setCarry(carry_set_0.carryFlip(4),4);
     734                carry_set_0.setCarry(carry_set_0.carryFlip(2),2);
    735735        }
    736736       
     
    756756                w = simd_or(lex.Hyphen,lex.QMark);
    757757                BitBlock v1;
    758                 carry_set_0.getPending64(0) = bitblock::srli<127>(pablo_blk_Advance_n_<v>(1,carry_set_0.getPending64(0),v1));
     758                carry_set_0.getPending64(0) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(v,carry_set_0.getPending64(0),v1));
    759759                BitBlock w1;
    760                 carry_set_0.getPending64(1) = bitblock::srli<127>(pablo_blk_Advance_n_<w>(1,carry_set_0.getPending64(1),w1));
     760                carry_set_0.getPending64(1) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(w,carry_set_0.getPending64(1),w1));
    761761                BitBlock LAngle_scope;
    762762                LAngle_scope = simd_andc(v1,w1);
     
    789789                BitBlock CtCDPI_Cursor;
    790790                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(0,13))))
     791                while (bitblock::any(CtCDPI_Cursor))
    792792                {
    793793                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
     
    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(0,4))))
     802                        if (bitblock::any(simd_or(PI_Cursor,carry_set_0.carryRange(4,4))))
    803803                        {
    804804                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
     
    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,PI_closer,carry_set_0.getCarry(7),PI_Cursor));
     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));
    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(0,4);
    828                         }
    829                         if (bitblock::any(simd_or(CD_Cursor,carry_set_0.carryRange(0,1))))
     827                                carry_set_0.carryDequeueEnqueue(4,4);
     828                        }
     829                        if (bitblock::any(simd_or(CD_Cursor,carry_set_0.carryRange(8,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,CD_closer,carry_set_0.getCarry(8),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));
    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(0,1);
    839                         }
    840                         if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.carryRange(0,5))))
     838                                carry_set_0.carryDequeueEnqueue(8,1);
     839                        }
     840                        if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.carryRange(9,5))))
    841841                        {
    842842                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
     
    848848                                carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_0.getCarry(11),Ct_Cursor));
    849849                                BitBlock _temp4;
    850                                 carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,DoubleHyphen,carry_set_0.getCarry(12),_temp4));
     850                                carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_not(DoubleHyphen),carry_set_0.getCarry(12),_temp4));
    851851                                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))))
     
    859859                        else
    860860                        {
    861                                 carry_set_0.carryDequeueEnqueue(0,5);
     861                                carry_set_0.carryDequeueEnqueue(9,5);
    862862                        }
    863863                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
     
    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,CtCDPI_opener,carry_set_0.getCarry(15),CtCDPI_Cursor));
    870                         while (bitblock::any(CtCDPI_Cursor))
    871                         {
    872                                 CarryDeclare(carry_set_1,13,0);
    873                                 CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
    874                                 BitBlock PI_Cursor;
    875                                 PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    876                                 BitBlock CD_Ct_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));
    878                                 BitBlock CD_Cursor;
    879                                 CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
    880                                 BitBlock Ct_Cursor;
    881                                 Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    882                                 if (bitblock::any(PI_Cursor))
    883                                 {
    884                                         ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
    885                                         carry_set_0.getCarry(17) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_0.getCarry(17),PI_Cursor));
    886                                         ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    887                                         BitBlock PI_name_end;
    888                                         carry_set_0.getCarry(18) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_0.getCarry(18),PI_name_end));
    889                                         BitBlock PI_error;
    890                                         PI_error = simd_and(PI_Cursor,PI_name_end);
    891                                         BitBlock PI_noWS;
    892                                         PI_noWS = simd_andc(PI_name_end,lex.WS);
    893                                         BitBlock _temp2;
    894                                         carry_set_0.getCarry(19) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_0.getCarry(19),_temp2));
    895                                         PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(_temp2,PI_closer)));
    896                                         if (bitblock::any(PI_error))
    897                                         {
    898                                                 assert_0_error(PI_error,"Error in PI syntax");
    899                                         }
    900                                         ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
    901                                         carry_set_0.getCarry(20) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,PI_closer,carry_set_0.getCarry(20),PI_Cursor));
    902                                         ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    903                                         CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
    904                                 }
    905                                 if (bitblock::any(CD_Cursor))
    906                                 {
    907                                         ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    908                                         carry_set_0.getCarry(21) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,CD_closer,carry_set_0.getCarry(21),CD_Cursor));
    909                                         ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    910                                         CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
    911                                 }
    912                                 if (bitblock::any(Ct_Cursor))
    913                                 {
    914                                         ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
    915                                         carry_set_0.getCarry(22) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(22),Ct_Cursor));
    916                                         BitBlock Ct_error;
    917                                         Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    918                                         BitBlock _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));
    921                                         BitBlock _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));
    924                                         if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    925                                         {
    926                                                 assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)),"Error in comment syntax");
    927                                         }
    928                                         ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
    929                                         CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
    930                                 }
    931                                 CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
    932                                 carry_set_0.getCarry(27) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_0.getCarry(27),ctCDPI_mask));
    933                                 if (bitblock::any(simd<1>::constant<0>()))
    934                                 {
    935                                         assert_0_error(simd<1>::constant<0>(),"Error in comment, CDATA or processing instruction syntax");
    936                                 }
    937                                 carry_set_0.getCarry(28) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,CtCDPI_opener,carry_set_0.getCarry(28),CtCDPI_Cursor));
    938                                 LocalCarryCombine(carry_set_0,carry_set_1,0,13);
    939                         }
    940                 }
    941                 else
    942                 {
    943                         carry_set_0.carryDequeueEnqueue(0,13);
     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));
    944870                }
    945871                BitBlock _temp5;
    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));
     872                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));
    947873                check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS,lex.LAngle),_temp5),CtCDPI_starts),EOF_mask);
    948874                marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
     
    973899                w = simd_or(lex.Hyphen,lex.QMark);
    974900                BitBlock v1;
    975                 carry_set_0.getPending64(0) = bitblock::srli<127>(pablo_blk_Advance_n_<v>(1,carry_set_0.getPending64(0),v1));
     901                carry_set_0.getPending64(0) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(v,carry_set_0.getPending64(0),v1));
    976902                BitBlock w1;
    977                 carry_set_0.getPending64(1) = bitblock::srli<127>(pablo_blk_Advance_n_<w>(1,carry_set_0.getPending64(1),w1));
     903                carry_set_0.getPending64(1) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(w,carry_set_0.getPending64(1),w1));
    978904                BitBlock LAngle_scope;
    979905                LAngle_scope = simd_andc(v1,w1);
     
    1006932                BitBlock CtCDPI_Cursor;
    1007933                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(0,13))))
     934                while (bitblock::any(CtCDPI_Cursor))
    1009935                {
    1010936                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
     
    1017943                        BitBlock Ct_Cursor;
    1018944                        Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    1019                         if (bitblock::any(simd_or(PI_Cursor,carry_set_0.carryRange(0,4))))
     945                        if (bitblock::any(simd_or(PI_Cursor,carry_set_0.carryRange(4,4))))
    1020946                        {
    1021947                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
     
    1036962                                }
    1037963                                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,PI_closer,carry_set_0.getCarry(7),PI_Cursor));
     964                                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));
    1039965                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    1040966                                CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     
    1042968                        else
    1043969                        {
    1044                                 carry_set_0.carryDequeueEnqueue(0,4);
    1045                         }
    1046                         if (bitblock::any(simd_or(CD_Cursor,carry_set_0.carryRange(0,1))))
     970                                carry_set_0.carryDequeueEnqueue(4,4);
     971                        }
     972                        if (bitblock::any(simd_or(CD_Cursor,carry_set_0.carryRange(8,1))))
    1047973                        {
    1048974                                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,CD_closer,carry_set_0.getCarry(8),CD_Cursor));
     975                                carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_not(CD_closer),carry_set_0.getCarry(8),CD_Cursor));
    1050976                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    1051977                                CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     
    1053979                        else
    1054980                        {
    1055                                 carry_set_0.carryDequeueEnqueue(0,1);
    1056                         }
    1057                         if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.carryRange(0,5))))
     981                                carry_set_0.carryDequeueEnqueue(8,1);
     982                        }
     983                        if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.carryRange(9,5))))
    1058984                        {
    1059985                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
     
    1065991                                carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_0.getCarry(11),Ct_Cursor));
    1066992                                BitBlock _temp4;
    1067                                 carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,DoubleHyphen,carry_set_0.getCarry(12),_temp4));
     993                                carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_not(DoubleHyphen),carry_set_0.getCarry(12),_temp4));
    1068994                                carry_set_0.getCarry(13) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_0.getCarry(13),Ct_Cursor));
    1069995                                if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
     
    10761002                        else
    10771003                        {
    1078                                 carry_set_0.carryDequeueEnqueue(0,5);
     1004                                carry_set_0.carryDequeueEnqueue(9,5);
    10791005                        }
    10801006                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
     
    10841010                                assert_0_error(simd_andc(ctCDPI_mask,EOF_mask),"Error in comment, CDATA or processing instruction syntax");
    10851011                        }
    1086                         carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,CtCDPI_opener,carry_set_0.getCarry(15),CtCDPI_Cursor));
    1087                         while (bitblock::any(simd_and(CtCDPI_Cursor,EOF_mask)))
    1088                         {
    1089                                 CarryDeclare(carry_set_1,13,0);
    1090                                 CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
    1091                                 BitBlock PI_Cursor;
    1092                                 PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    1093                                 BitBlock CD_Ct_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));
    1095                                 BitBlock CD_Cursor;
    1096                                 CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
    1097                                 BitBlock Ct_Cursor;
    1098                                 Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    1099                                 if (bitblock::any(PI_Cursor))
    1100                                 {
    1101                                         ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
    1102                                         carry_set_0.getCarry(17) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_0.getCarry(17),PI_Cursor));
    1103                                         ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    1104                                         BitBlock PI_name_end;
    1105                                         carry_set_0.getCarry(18) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_0.getCarry(18),PI_name_end));
    1106                                         BitBlock PI_error;
    1107                                         PI_error = simd_and(PI_Cursor,PI_name_end);
    1108                                         BitBlock PI_noWS;
    1109                                         PI_noWS = simd_andc(PI_name_end,lex.WS);
    1110                                         BitBlock _temp2;
    1111                                         carry_set_0.getCarry(19) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_0.getCarry(19),_temp2));
    1112                                         PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(_temp2,PI_closer)));
    1113                                         if (bitblock::any(PI_error))
    1114                                         {
    1115                                                 assert_0_error(PI_error,"Error in PI syntax");
    1116                                         }
    1117                                         ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
    1118                                         carry_set_0.getCarry(20) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,PI_closer,carry_set_0.getCarry(20),PI_Cursor));
    1119                                         ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    1120                                         CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
    1121                                 }
    1122                                 if (bitblock::any(CD_Cursor))
    1123                                 {
    1124                                         ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    1125                                         carry_set_0.getCarry(21) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,CD_closer,carry_set_0.getCarry(21),CD_Cursor));
    1126                                         ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    1127                                         CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
    1128                                 }
    1129                                 if (bitblock::any(Ct_Cursor))
    1130                                 {
    1131                                         ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
    1132                                         carry_set_0.getCarry(22) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(22),Ct_Cursor));
    1133                                         BitBlock Ct_error;
    1134                                         Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    1135                                         BitBlock _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));
    1138                                         BitBlock _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));
    1141                                         if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    1142                                         {
    1143                                                 assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)),"Error in comment syntax");
    1144                                         }
    1145                                         ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
    1146                                         CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
    1147                                 }
    1148                                 CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
    1149                                 carry_set_0.getCarry(27) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_0.getCarry(27),ctCDPI_mask));
    1150                                 if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
    1151                                 {
    1152                                         assert_0_error(simd_andc(ctCDPI_mask,EOF_mask),"Error in comment, CDATA or processing instruction syntax");
    1153                                 }
    1154                                 carry_set_0.getCarry(28) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,CtCDPI_opener,carry_set_0.getCarry(28),CtCDPI_Cursor));
    1155                                 LocalCarryCombine(carry_set_0,carry_set_1,0,13);
    1156                         }
    1157                 }
    1158                 else
    1159                 {
    1160                         carry_set_0.carryDequeueEnqueue(0,13);
     1012                        carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_not(CtCDPI_opener),carry_set_0.getCarry(15),CtCDPI_Cursor));
    11611013                }
    11621014                BitBlock _temp5;
    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));
     1015                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));
    11641016                check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS,lex.LAngle),_temp5),CtCDPI_starts),EOF_mask);
    11651017                marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
     
    11681020        }
    11691021       
    1170         CarryDeclare(carry_set_0,30,2);
     1022        CarryDeclare(carry_set_0,17,2);
    11711023};
    11721024 
     
    11981050                tag_Callouts.AttVal_starts = simd<1>::constant<0>();
    11991051                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(0,8))))
     1052                if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.carryRange(1,8))))
    12011053                {
    12021054                        BitBlock AfterWS;
     
    12051057                        BitBlock AttNameStart;
    12061058                        AttNameStart = simd_andc(AfterWS,AttListDelim);
    1207                         if (bitblock::any(simd_or(AttNameStart,carry_set_0.carryRange(0,7))))
     1059                        while (bitblock::any(AttNameStart))
    12081060                        {
    12091061                                ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
     
    12121064                                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_0.getCarry(2),AttNameFollow));
    12131065                                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(0,1))))
     1066                                if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.carryRange(3,1))))
    12151067                                {
    12161068                                        carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_0.getCarry(3),EqExpected));
     
    12191071                                {
    12201072                                        EqExpected = AttNameFollow;
    1221                                         carry_set_0.carryDequeueEnqueue(0,1);
     1073                                        carry_set_0.carryDequeueEnqueue(3,1);
    12221074                                }
    12231075                                ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
     
    12301082                                SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    12311083                                BitBlock DQuoteAttEnd;
    1232                                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,DQuoteDelim,carry_set_0.getCarry(5),DQuoteAttEnd));
     1084                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_not(DQuoteDelim),carry_set_0.getCarry(5),DQuoteAttEnd));
    12331085                                BitBlock SQuoteAttEnd;
    1234                                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,SQuoteDelim,carry_set_0.getCarry(6),SQuoteAttEnd));
     1086                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_not(SQuoteDelim),carry_set_0.getCarry(6),SQuoteAttEnd));
    12351087                                BitBlock AttValEnd;
    12361088                                AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
     
    12391091                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(7),AttValFollow));
    12401092                                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(0,1))))
     1093                                if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.carryRange(8,1))))
    12421094                                {
    12431095                                        carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_0.getCarry(8),AfterWS));
     
    12491101                                        AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
    12501102                                        AttNameStart = simd_andc(AttValFollow,AttListDelim);
    1251                                         carry_set_0.carryDequeueEnqueue(0,1);
     1103                                        carry_set_0.carryDequeueEnqueue(8,1);
    12521104                                }
    12531105                                ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
    1254                                 while (bitblock::any(AttNameStart))
    1255                                 {
    1256                                         CarryDeclare(carry_set_1,7,0);
    1257                                         ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
    1258                                         tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
    1259                                         BitBlock AttNameFollow;
    1260                                         carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_0.getCarry(9),AttNameFollow));
    1261                                         tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
    1262                                         if (bitblock::any(simd_and(AttNameFollow,lex.WS)))
    1263                                         {
    1264                                                 carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_0.getCarry(10),EqExpected));
    1265                                         }
    1266                                         else
    1267                                         {
    1268                                                 EqExpected = AttNameFollow;
    1269                                         }
    1270                                         ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
    1271                                         BitBlock AttValPos;
    1272                                         carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_0.getCarry(11),AttValPos));
    1273                                         tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
    1274                                         BitBlock DQuoteAttVal;
    1275                                         DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
    1276                                         BitBlock SQuoteAttVal;
    1277                                         SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    1278                                         BitBlock DQuoteAttEnd;
    1279                                         carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,DQuoteDelim,carry_set_0.getCarry(12),DQuoteAttEnd));
    1280                                         BitBlock SQuoteAttEnd;
    1281                                         carry_set_0.getCarry(13) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,SQuoteDelim,carry_set_0.getCarry(13),SQuoteAttEnd));
    1282                                         BitBlock AttValEnd;
    1283                                         AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
    1284                                         ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
    1285                                         BitBlock AttValFollow;
    1286                                         carry_set_0.getCarry(14) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(14),AttValFollow));
    1287                                         tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
    1288                                         if (bitblock::any(simd_and(AttValFollow,lex.WS)))
    1289                                         {
    1290                                                 carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_0.getCarry(15),AfterWS));
    1291                                                 AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
    1292                                                 AttNameStart = simd_andc(AfterWS,AttListDelim);
    1293                                         }
    1294                                         else
    1295                                         {
    1296                                                 AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
    1297                                                 AttNameStart = simd_andc(AttValFollow,AttListDelim);
    1298                                         }
    1299                                         ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
    1300                                         LocalCarryCombine(carry_set_0,carry_set_1,0,7);
    1301                                 }
    1302                         }
    1303                         else
    1304                         {
    1305                                 carry_set_0.carryDequeueEnqueue(0,7);
    13061106                        }
    13071107                }
     
    13101110                        AttListEnd = simd_and(tag_Callouts.ElemName_ends,AttListDelim);
    13111111                        ParseError = simd_or(ParseError,simd_andc(tag_Callouts.ElemName_ends,AttListDelim));
    1312                         carry_set_0.carryDequeueEnqueue(0,8);
     1112                        carry_set_0.carryDequeueEnqueue(1,8);
    13131113                }
    13141114                BitBlock STagEnds;
    13151115                STagEnds = simd_and(AttListEnd,lex.RAngle);
    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));
     1116                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));
    13171117                ParseError = simd_or(ParseError,simd_andc(tag_Callouts.EmptyTag_marks,lex.RAngle));
    13181118                BitBlock EndTagEnds;
    1319                 carry_set_0.getCarry(17) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.getCarry(17),EndTagEnds));
    1320                 if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.carryRange(0,1))))
    1321                 {
    1322                         carry_set_0.getCarry(18) = bitblock::srli<127>(pablo_blk_ScanThru(EndTagEnds,lex.WS,carry_set_0.getCarry(18),EndTagEnds));
     1119                carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.getCarry(10),EndTagEnds));
     1120                if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.carryRange(11,1))))
     1121                {
     1122                        carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_ScanThru(EndTagEnds,lex.WS,carry_set_0.getCarry(11),EndTagEnds));
    13231123                }
    13241124                else
    13251125                {
    1326                         carry_set_0.carryDequeueEnqueue(0,1);
     1126                        carry_set_0.carryDequeueEnqueue(11,1);
    13271127                }
    13281128                ParseError = simd_or(ParseError,simd_andc(EndTagEnds,lex.RAngle));
     
    13311131                        assert_0_error(ParseError,"Tag parsing error found");
    13321132                }
    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));
     1133                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));
    13341134                carry_set_0.carryAdjust(13);
    13351135        }
     
    13561156                tag_Callouts.AttVal_starts = simd<1>::constant<0>();
    13571157                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(0,8))))
     1158                if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.carryRange(1,8))))
    13591159                {
    13601160                        BitBlock AfterWS;
     
    13631163                        BitBlock AttNameStart;
    13641164                        AttNameStart = simd_andc(AfterWS,AttListDelim);
    1365                         if (bitblock::any(simd_or(simd_and(AttNameStart,EOF_mask),carry_set_0.carryRange(0,7))))
     1165                        while (bitblock::any(AttNameStart))
    13661166                        {
    13671167                                ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
     
    13701170                                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_0.getCarry(2),AttNameFollow));
    13711171                                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(0,1))))
     1172                                if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.carryRange(3,1))))
    13731173                                {
    13741174                                        carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_0.getCarry(3),EqExpected));
     
    13771177                                {
    13781178                                        EqExpected = AttNameFollow;
    1379                                         carry_set_0.carryDequeueEnqueue(0,1);
     1179                                        carry_set_0.carryDequeueEnqueue(3,1);
    13801180                                }
    13811181                                ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
     
    13881188                                SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    13891189                                BitBlock DQuoteAttEnd;
    1390                                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,DQuoteDelim,carry_set_0.getCarry(5),DQuoteAttEnd));
     1190                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_not(DQuoteDelim),carry_set_0.getCarry(5),DQuoteAttEnd));
    13911191                                BitBlock SQuoteAttEnd;
    1392                                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,SQuoteDelim,carry_set_0.getCarry(6),SQuoteAttEnd));
     1192                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_not(SQuoteDelim),carry_set_0.getCarry(6),SQuoteAttEnd));
    13931193                                BitBlock AttValEnd;
    13941194                                AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
     
    13971197                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(7),AttValFollow));
    13981198                                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(0,1))))
     1199                                if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.carryRange(8,1))))
    14001200                                {
    14011201                                        carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_0.getCarry(8),AfterWS));
     
    14071207                                        AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
    14081208                                        AttNameStart = simd_andc(AttValFollow,AttListDelim);
    1409                                         carry_set_0.carryDequeueEnqueue(0,1);
     1209                                        carry_set_0.carryDequeueEnqueue(8,1);
    14101210                                }
    14111211                                ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
    1412                                 while (bitblock::any(simd_and(AttNameStart,EOF_mask)))
    1413                                 {
    1414                                         CarryDeclare(carry_set_1,7,0);
    1415                                         ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
    1416                                         tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
    1417                                         BitBlock AttNameFollow;
    1418                                         carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_0.getCarry(9),AttNameFollow));
    1419                                         tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
    1420                                         if (bitblock::any(simd_and(AttNameFollow,lex.WS)))
    1421                                         {
    1422                                                 carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_0.getCarry(10),EqExpected));
    1423                                         }
    1424                                         else
    1425                                         {
    1426                                                 EqExpected = AttNameFollow;
    1427                                         }
    1428                                         ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
    1429                                         BitBlock AttValPos;
    1430                                         carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_0.getCarry(11),AttValPos));
    1431                                         tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
    1432                                         BitBlock DQuoteAttVal;
    1433                                         DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
    1434                                         BitBlock SQuoteAttVal;
    1435                                         SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    1436                                         BitBlock DQuoteAttEnd;
    1437                                         carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,DQuoteDelim,carry_set_0.getCarry(12),DQuoteAttEnd));
    1438                                         BitBlock SQuoteAttEnd;
    1439                                         carry_set_0.getCarry(13) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,SQuoteDelim,carry_set_0.getCarry(13),SQuoteAttEnd));
    1440                                         BitBlock AttValEnd;
    1441                                         AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
    1442                                         ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
    1443                                         BitBlock AttValFollow;
    1444                                         carry_set_0.getCarry(14) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(14),AttValFollow));
    1445                                         tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
    1446                                         if (bitblock::any(simd_and(AttValFollow,lex.WS)))
    1447                                         {
    1448                                                 carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_0.getCarry(15),AfterWS));
    1449                                                 AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
    1450                                                 AttNameStart = simd_andc(AfterWS,AttListDelim);
    1451                                         }
    1452                                         else
    1453                                         {
    1454                                                 AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
    1455                                                 AttNameStart = simd_andc(AttValFollow,AttListDelim);
    1456                                         }
    1457                                         ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
    1458                                         LocalCarryCombine(carry_set_0,carry_set_1,0,7);
    1459                                 }
    1460                         }
    1461                         else
    1462                         {
    1463                                 carry_set_0.carryDequeueEnqueue(0,7);
    14641212                        }
    14651213                }
     
    14681216                        AttListEnd = simd_and(tag_Callouts.ElemName_ends,AttListDelim);
    14691217                        ParseError = simd_or(ParseError,simd_andc(tag_Callouts.ElemName_ends,AttListDelim));
    1470                         carry_set_0.carryDequeueEnqueue(0,8);
     1218                        carry_set_0.carryDequeueEnqueue(1,8);
    14711219                }
    14721220                BitBlock STagEnds;
    14731221                STagEnds = simd_and(AttListEnd,lex.RAngle);
    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));
     1222                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));
    14751223                ParseError = simd_or(ParseError,simd_andc(tag_Callouts.EmptyTag_marks,lex.RAngle));
    14761224                BitBlock EndTagEnds;
    1477                 carry_set_0.getCarry(17) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.getCarry(17),EndTagEnds));
    1478                 if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.carryRange(0,1))))
    1479                 {
    1480                         carry_set_0.getCarry(18) = bitblock::srli<127>(pablo_blk_ScanThru(EndTagEnds,lex.WS,carry_set_0.getCarry(18),EndTagEnds));
     1225                carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.getCarry(10),EndTagEnds));
     1226                if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.carryRange(11,1))))
     1227                {
     1228                        carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_ScanThru(EndTagEnds,lex.WS,carry_set_0.getCarry(11),EndTagEnds));
    14811229                }
    14821230                else
    14831231                {
    1484                         carry_set_0.carryDequeueEnqueue(0,1);
     1232                        carry_set_0.carryDequeueEnqueue(11,1);
    14851233                }
    14861234                ParseError = simd_or(ParseError,simd_andc(EndTagEnds,lex.RAngle));
     
    14891237                        assert_0_error(ParseError,"Tag parsing error found");
    14901238                }
    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));
    1492         }
    1493        
    1494         CarryDeclare(carry_set_0,20,0);
     1239                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));
     1240        }
     1241       
     1242        CarryDeclare(carry_set_0,13,0);
    14951243};
    14961244 
Note: See TracChangeset for help on using the changeset viewer.