Changeset 3387 for proto/pabloj/trunk


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.

Location:
proto/pabloj/trunk
Files:
2 deleted
14 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 
  • proto/pabloj/trunk/src/application/generators/ASTGenerator.java

    r2998 r3387  
    3434                return ASTTree;
    3535        }               
    36        
    3736               
    3837        static private boolean thereAreErrors() {
  • proto/pabloj/trunk/src/application/generators/ApplicationGenerator.java

    r3384 r3387  
    77package application.generators;
    88
    9 import java.util.ArrayList;
    10 import java.util.LinkedHashMap;
    11 import java.util.Map;
    12 
    139import toolchain.pabloB.codeGenerator.idisa.IDISABuiltin2C;
    1410import toolchain.pabloB.codeGenerator.idisa.IDISABuiltin2CPP;
     
    1713import toolchain.pabloB.transformer.visitors.pabloB2PabloB.PabloB2PabloBController;
    1814
    19 import toolchain.pabloS.ast.Accessors;
    2015import toolchain.pabloS.transformer.visitors.pabloS2PabloB.PabloS2PabloBController;
    2116import toolchain.pabloS.transformer.visitors.pabloS2PabloB.PabloS2PabloBXFormer;
    2217import toolchain.pabloS.transformer.visitors.pabloS2pabloS.PabloS2SPabloController;
    23 import toolchain.pabloS.transformer.visitors.pabloS2pabloS.SomeNameStreamFunctionPropertySet;
    24 import toolchain.pabloS.transformer.visitors.pabloS2pabloS.SomeNameStreamFunctionPropertySetFactory;
    25 import toolchain.pabloS.transformer.visitors.pabloS2pabloS.StreamFunctionDefs;
    2618
    2719import application.config.Configuration;
     
    9082            //////////////////////////////////////////////////////////////
    9183            // PabloS to PabloB transformation
    92                         PabloS2PabloBXFormer.setPabloSBuiltinEncoder(pabloSbuiltinsEncoder);
    93                         PabloS2PabloBXFormer.setCarrySetEncoder(carrySetEncoder);
    94                         pabloBAST = PabloS2PabloBXFormer.apply(decoratedTree, finalBlockDecoratedTree);
     84                        pabloBAST = PabloS2PabloBXFormer.apply(pabloSbuiltinsEncoder, carrySetEncoder, decoratedTree, finalBlockDecoratedTree);
    9585                       
    9686                } else if (applicationConfiguration.getSource() == SourceLanguage.PABLO_B) {
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Accessors.java

    r3384 r3387  
    102102            return node.child(1);
    103103        }
    104        
    105104        public static boolean hasParameters(FuncDefNode node) {
    106                 ASTNode child2 = node.child(2);
    107                
    108                 if ((node.nChildren()) > 2 && (child2 instanceof ParameterListNode)) {
    109                         return true;
    110                 }
    111                 return false;
    112         }       
    113                
     105            return (node.nChildren()) > 2 && (node.child(2) instanceof ParameterListNode);
     106        }
     107        public static ParameterListNode parameterListNode(FuncDefNode node) {   
     108            return (ParameterListNode) node.child(2);
     109        }
     110        public static BlockStmtNode body(FuncDefNode node) {
     111            return blockStmtNode(node);
     112        }
    114113        public static BlockStmtNode blockStmtNode(FuncDefNode node) {
    115114                int blockStmtNodeIndex;
     
    194193        }       
    195194       
    196         public static boolean hasElseBlockStmt(IfStmtNode node) {
    197                 return node.nChildren() > 2;
    198         }
    199        
    200195        public static BlockStmtNode elseBlockStmt(IfStmtNode node) {
    201196                return (BlockStmtNode) node.child(2);
    202197        }       
     198
     199        public static BlockStmtNode elseClause(IfStmtNode node) {
     200            return (BlockStmtNode) node.child(2);
     201        }
     202       
     203        public static boolean hasElseBlockStmt(IfStmtNode node) {
     204            return hasElseClause(node);
     205        }   
     206
     207        public static boolean hasElseClause(IfStmtNode node) {
     208            return node.nChildren() > 2;
     209        }
    203210       
    204211    ////////////////////////////////////////////////////////////////////////////
     
    296303        }       
    297304
     305        ////////////////////////////////////////////////////////////////////////////
     306        // ParameterNode
     307        ////////////////////////////////////////////////////////////////////////////
     308        public static ASTNode typeNode(ParameterNode node) {
     309            return node.child(0);
     310        }
     311
     312        public static ASTNode nameNode(ParameterNode node) {
     313            return node.child(1);
     314        }
     315
     316//      public static Type declarationType(ParameterNode node) {
     317//          ASTNode typeNode = typeNode(node);
     318//          return typeNode.getType();
     319//      }
     320//      public static IdentifierNode variableNode(ParameterNode node) {
     321//          return (IdentifierNode)(node.child(1));
     322//      }       
     323       
    298324    ////////////////////////////////////////////////////////////////////////////
    299325    // StructMemberNode
     
    406432        } else if(node instanceof KernelDefNode) {
    407433            return name(nameNode((KernelDefNode)node));
    408         }
     434        } else if(node instanceof ParameterNode) {
     435            return name(nameNode((ParameterNode)node));
     436        }
    409437        assert false : "Accessors.name(ASTNode node) method not implemented on node class : " + node.getClass();
    410438        return null;
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Generators.java

    r3384 r3387  
    77import pabloB.tokens.*;
    88import pabloB.inputHandler.Locator;
    9 import pabloB.lexicalAnalyzer.LexicalType;
    109import pabloB.tokens.IdentifierToken;
    1110import pabloB.lexicalAnalyzer.Lextant;
    12 
     11import pabloB.lexicalAnalyzer.LexicalType;
    1312
    1413import toolchain.pabloB.ast.Accessors;
    1514
     15import toolchain.pabloB.lang.PabloBBuiltin;
    1616import toolchain.pabloB.lang.idisa.IDISABuiltin;
    1717import toolchain.pabloS.lang.carrySet.CarrySetBuiltin;
     
    3535                if(sToken instanceof pabloS.tokens.CharacterToken) {
    3636                       
    37                         bToken = pabloB.tokens.CharacterToken.make(pabloB.lexicalAnalyzer.LexicalType.LEXTANT,
     37                        bToken = pabloB.tokens.CharacterToken.make(LexicalType.LEXTANT,
    3838                                                                                                                makeTextLocation(sToken.getLocation()),
    3939                                                                                                                sToken.getLexeme());
     
    4141                } else if (sToken instanceof pabloS.tokens.CommentToken) {
    4242
    43                         bToken = pabloB.tokens.CharacterToken.make(pabloB.lexicalAnalyzer.LexicalType.IGNORE,
     43                        bToken = pabloB.tokens.CharacterToken.make(LexicalType.IGNORE,
    4444                                        makeTextLocation(sToken.getLocation()),
    4545                                        sToken.getLexeme());
     
    5151                } else if (sToken instanceof pabloS.tokens.IdentifierToken) {
    5252
    53                         bToken = pabloB.tokens.IdentifierToken.make(pabloB.lexicalAnalyzer.LexicalType.IDENTIFIER,
     53                        bToken = pabloB.tokens.IdentifierToken.make(LexicalType.IDENTIFIER,
    5454                                        makeTextLocation(sToken.getLocation()),
    5555                                        sToken.getLexeme());                   
     
    5757                } else if (sToken instanceof pabloS.tokens.IntConstantToken) {
    5858
    59                         bToken = pabloB.tokens.IntConstantToken.make(pabloB.lexicalAnalyzer.LexicalType.INTEGER_CONST,
     59                        bToken = pabloB.tokens.IntConstantToken.make(LexicalType.INTEGER_CONST,
    6060                                        makeTextLocation(sToken.getLocation()),
    6161                                        sToken.getLexeme());                                           
     
    6969                } else if (sToken instanceof pabloS.tokens.NullToken) {
    7070
    71                         bToken = pabloB.tokens.NullToken.make(pabloB.lexicalAnalyzer.LexicalType.NONE,
     71                        bToken = pabloB.tokens.NullToken.make(LexicalType.NONE,
    7272                                        makeTextLocation(sToken.getLocation()));                                               
    7373                       
     
    7777                        String stringLexeme = string.substring(1,string.length()-1); // strip leading " and trailing " PabloS string constant tokens                   
    7878                       
    79                         bToken = pabloB.tokens.StringConstantToken.make(pabloB.lexicalAnalyzer.LexicalType.STRING,
     79                        bToken = pabloB.tokens.StringConstantToken.make(LexicalType.STRING,
    8080                                        makeTextLocation(sToken.getLocation()),
    8181                                        stringLexeme);                                                                 
     
    8383                } else if (sToken instanceof pabloS.tokens.WhitespaceToken) {
    8484
    85                         bToken = pabloB.tokens.WhitespaceToken.make(pabloB.lexicalAnalyzer.LexicalType.IGNORE,
     85                        bToken = pabloB.tokens.WhitespaceToken.make(LexicalType.IGNORE,
    8686                                        makeTextLocation(sToken.getLocation()),
    8787                                        sToken.getLexeme());                           
     
    229229    }
    230230   
     231    //////////////////////////////////////////////////////////////////////////
     232    // Function defs
     233   
     234    public static void appendParameter(FuncDefNode funcDefNode, ParameterNode parameterNode) {
     235       
     236        ParameterListNode parameterListNode = null;
     237       
     238        if(!Accessors.hasParameters(funcDefNode)) {
     239            parameterListNode = new ParameterListNode(parameterNode.getToken()); // likely needs a fix
     240            funcDefNode.insertAfterChild(Accessors.funcIdentifier(funcDefNode), parameterListNode);
     241        } else {
     242            parameterListNode = Accessors.parameterListNode(funcDefNode);
     243        }
     244       
     245        parameterListNode.appendChild(parameterNode);
     246       
     247    }
    231248   
    232249    //////////////////////////////////////////////////////////////////////////
     
    372389   
    373390    ///////////////////////////////////////////////////////////////////
    374     // Carry builtin calls   
    375    
    376 //    public static ASTNode makeGetCallCarryForBuiltin(Locator locator, PabloSBuiltin builtin, int index, Context context) {
    377 //        if(builtin.isCarryN()) {
    378 //            return makePending64Call(locator, index, context);
    379 //        } else {
    380 //            return makeGetCarryCall(locator, index, context);
    381 //        }
    382 //    }
    383 
    384     public static ASTNode makeGetCarryCall(Locator locator, Context context, int index) {
     391    // Carry builtins   
     392    public static ASTNode makeGetCarryCall(Locator locator, Context context, int carry1Position) {
    385393        return Generators.makeFuncCallNode(
    386394                locator,
    387395                context.getCarrySetIdentifier(),
    388396                context.getCarrySetEncoder().getName(CarrySetBuiltin.GETCARRY),
    389                 Generators.makeIntegerConstantNode(locator, index));
    390     }
    391 
    392     public static ASTNode makePending64Call(Locator locator, Context context, int index) {
     397                Generators.makeIntegerConstantNode(locator, carry1Position));
     398    }
     399
     400    public static ASTNode makePending64Call(Locator locator, Context context, int carry1Position) {
    393401        return Generators.makeFuncCallNode(
    394402                locator,
    395403                context.getCarrySetIdentifier(),
    396404                context.getCarrySetEncoder().getName(CarrySetBuiltin.PENDING64),
    397                 Generators.makeIntegerConstantNode(locator, index));
     405                Generators.makeIntegerConstantNode(locator, carry1Position));
    398406    }   
    399407   
    400     public static FuncCallNode makeCarryFlipCall(Locator locator, int index, Context context) {
    401        
    402         IntegerConstantNode indexNode = Generators.makeIntegerConstantNode(locator, index);
     408    public static FuncCallNode makeCarryFlipCall(Locator locator, Context context, int carry1Position) {
     409       
     410        IntegerConstantNode indexNode = Generators.makeIntegerConstantNode(locator, carry1Position);
    403411       
    404412       
     
    414422    }
    415423   
    416     public static FuncCallNode makeCarryDeclareCall(Locator locator, int carry1Count, int carryNCount, Context context) {
     424    public static IdisaFuncCallNode makeBitwiseOrCarryTest(ASTNode condition,
     425            Context context,
     426            int carry1Position,
     427            int carry1Count) {
     428       
     429        Locator locator = (Locator)condition;
     430
     431        ASTNode carry1PositionNode  = Generators.leaf(carry1Position, locator);
     432        ASTNode carry1CountNode = Generators.leaf(carry1Count, locator);
     433        ASTNode carryRange = Generators.makeFuncCallNode(
     434                locator,
     435                context.getCarrySetIdentifier(),
     436                context.getCarrySetEncoder().getName(CarrySetBuiltin.CARRYRANGE),
     437                Generators.arguments(carry1PositionNode, carry1CountNode));
     438       
     439        return Generators.makeIdisaFuncCallNode(locator, SIMD_OR, BITBLOCK_SIZE, Generators.arguments(condition, carryRange));
     440       
     441       
     442    }   
     443   
     444    public static FuncCallNode makeCarryDeclareCall(Locator locator, Context context, int carry1Count, int carryNCount) {
    417445       
    418446        IdentifierNode carrySetIdentifier       =   Generators.makeIdentifierNode(locator, context.getCarrySetIdentifier());
     
    425453                                                                                                     carry1CountNode,
    426454                                                                                                     carryNCountNode));       
    427        
    428        
    429        
    430455                                                                                   
    431456        return carryDeclareFuncCall;
    432457    }
    433    
     458 
     459    public static FuncCallNode makeCarryAdjustmentCall(Locator location, Context context, int carry1Count) {
     460        IntegerConstantNode carry1CountNode =  Generators.leaf(carry1Count, location);
     461
     462        FuncCallNode carryAdjustment = Generators.makeFuncCallNode(
     463                location,
     464                context.getCarrySetIdentifier(),                                   
     465                context.getCarrySetEncoder().getName(CarrySetBuiltin.CARRYADJUST),
     466                Generators.arguments(carry1CountNode));
     467        return carryAdjustment;
     468    }   
     469
     470    public static FuncCallNode makeCarryDequeueEnqueueCall(Locator locator, Context context, int carry1Position, int carry1Count) {
     471       
     472        IntegerConstantNode carry1PositionNode  =   Generators.makeIntegerConstantNode(locator, carry1Position);
     473        IntegerConstantNode carry1CountNode     =   Generators.makeIntegerConstantNode(locator, carry1Count);
     474       
     475        FuncCallNode carryAdjustment = Generators.makeFuncCallNode(
     476                locator,
     477                context.getCarrySetIdentifier(),                                   
     478                context.getCarrySetEncoder().getName(CarrySetBuiltin.CARRYDEQUEUEENQUEUE),
     479                Generators.arguments(carry1PositionNode, carry1CountNode));
     480        return carryAdjustment;
     481    } 
     482   
     483    public static IntegerConstantNode leaf(int n, Locator locator) {
     484        return Generators.makeIntegerConstantNode(locator, n);
     485    } 
     486
     487    ///////////////////////////////////////////////////////////////////
     488    // SIMD EOF_mask calls
     489    public static ParameterNode makeEOFMaskParameter(Locator locator) {
     490
     491        Token parameterNodeToken = Generators.makeLextantToken(locator, pabloB.lexicalAnalyzer.Lextant.BITBLOCK);
     492        ParameterNode parameterNode = new ParameterNode(parameterNodeToken);
     493
     494        Token bitBlockTypeToken = Generators.makeLextantToken(locator, pabloB.lexicalAnalyzer.Lextant.BITBLOCK);
     495        BitBlockTypeNode streamTypeNode = new BitBlockTypeNode(bitBlockTypeToken);
     496        IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, PabloBBuiltin.EOF_MASK.pabloBName()); // encoder.getName(PabloSBuiltin.EOF_MASK));
     497
     498        parameterNode.appendChild(streamTypeNode);
     499        parameterNode.appendChild(identifierNode);
     500
     501        return parameterNode;
     502    }
     503   
     504    ///////////////////////////////////////////////////////////////////
     505    // helpers
    434506    public static ASTNode[] arguments(ASTNode...astNodes) {
    435507        return astNodes;
  • proto/pabloj/trunk/src/toolchain/pabloB/codeGenerator/util/CodeStore.java

    r3321 r3387  
    3131        private String resultVarName = "codeStoreNoVar";
    3232
    33         public boolean isEmpty() {
     33        public boolean hasCode() {
    3434            return code.isEmpty();
    3535        }
     
    104104        public void addAll(List<CodeStore> others, int relativeIndent) {
    105105                for(CodeStore other : others) {
    106                         addAll(other,0);
     106                        addAll(other,relativeIndent);
    107107                }
    108108        }       
  • proto/pabloj/trunk/src/toolchain/pabloB/codeGenerator/visitors/Unparser.java

    r3386 r3387  
    6464        }
    6565               
    66 
     66    @SuppressWarnings("unused")
    6767    private boolean hasCode(List<CodeStore> childResults) {
    6868        boolean hasCode = false;
    6969        for(CodeStore child: childResults) {
    70             if(!child.isEmpty()) {
     70            if(!child.hasCode()) {
    7171                hasCode = true;
    7272            }
     
    9999               
    100100                String kernelName = childResults.get(0).getResultVarName();
    101                
    102 
    103                
    104                
    105                 CodeStore initDef = childResults.get(1); // KH: breakage
     101                               
     102                CodeStore initDef = childResults.get(1);
    106103               
    107104                CodeStore funcDefCodeStore = childResults.get(2);
    108105               
    109106                code.addFormattedLine("struct %s ", kernelName);
    110                
    111                 code.addLine("");
     107                code.addLine("{");
     108               
    112109                code.indentedFormattedLine("%s()", kernelName);
    113110                code.addLine("{");
    114111                code.addAll(initDef, 1);
    115112               
    116                 if(!initDef.isEmpty()) {
     113                if(!initDef.hasCode()) {
    117114                    code.dedentedLine("}");
    118115                } else {
     
    195192                code.addAll(blockStmtCodeStore, 1);
    196193               
    197                 if(!blockStmtCodeStore.isEmpty()) {
     194                if(!blockStmtCodeStore.hasCode()) {
    198195                    code.dedentedLine("}");
    199196                } else {
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Accessors.java

    r3384 r3387  
    233233                return lexeme(funcIdentifier(node));
    234234        }
    235         public static int numParameters(FuncDefNode node) {
    236                 if(hasParameters(node)) {
    237                         return parameterListNode(node).nChildren();
    238                 }
    239                 else {
    240                         return 0;
    241                 }
    242         }
    243235        public static boolean hasParameters(FuncDefNode node) {
    244236                return (node.nChildren()) > 2 && (node.child(2) instanceof ParameterListNode);
    245237        }
     238        public static int numParameters(FuncDefNode node) {
     239            if(hasParameters(node)) {
     240                return parameterListNode(node).nChildren();
     241            }
     242            else {
     243                return 0;
     244            }
     245        }
    246246        public static ParameterListNode parameterListNode(FuncDefNode node) {   
    247                 if(hasParameters(node)) {
    248                         return (ParameterListNode) node.child(2);
    249                 }
    250                
    251                 return null;
     247                return (ParameterListNode) node.child(2);
    252248        }
    253249        public static ParameterNode parameter(FuncDefNode node, int i) {
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Generators.java

    r3378 r3387  
    241241       
    242242        ///////////////////////////////////////////////////////////////////
    243         // SIMD EOF_mask calls
     243        // SIMD EOF_mask calls // TODO - KH : move to PabloB.Generators
    244244        public static FuncCallNode makeSIMDAndEOFMaskFuncCall(ASTNode node, PabloSBuiltinEncoder encoder) {
    245245                Locator location = (Locator)node;
     
    262262                return Generators.makeFuncCallNode(node.getToken(), IDISASIMDBitwiseBuiltins.NOT.Name(), args);
    263263        }               
    264        
    265         public static ParameterNode makeEOFMaskParameter(Locator locator, PabloSBuiltinEncoder encoder) {
    266                
    267                 Token parameterNodeToken = Generators.makeLextantToken(locator, Lextant.STREAM);
    268                 ParameterNode parameterNode = new ParameterNode(parameterNodeToken);
    269                
    270                 Token streamTypeToken = Generators.makeLextantToken(locator, Lextant.STREAM);
    271                 StreamTypeNode streamTypeNode = new StreamTypeNode(streamTypeToken);
    272                 IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, PabloBBuiltin.EOF_MASK.pabloBName()); // encoder.getName(PabloSBuiltin.EOF_MASK));
    273                
    274                 parameterNode.appendChild(streamTypeNode);
    275                 parameterNode.appendChild(identifierNode);
    276                
    277                 return parameterNode;
    278         }
    279 
    280     ///////////////////////////////////////////////////////////////////
    281     // Carry builtin calls
    282        
    283         // TODO - KH: remove all Carry builtin calls from the PabloS generators
    284        
    285     public static ASTNode makeGetCallCarryForBuiltin(Locator locator, PabloSBuiltin builtin, int index, Context context) {
    286         if(builtin.isCarryN()) {
    287             return makePending64Call(locator, index, context);
    288         } else {
    289             return makeGetCarryCall(locator, index, context);
    290         }
    291     }
    292    
    293     public static ASTNode makeGetCarryCall(Locator locator, int index, Context context) {
    294         return Generators.makeFuncCallNode(
    295                 locator,
    296                 context.getCarrySetIdentifier(),
    297                 context.getCarrySetEncoder().getName(CarrySetBuiltin.GETCARRY),
    298                 Generators.makeIntegerConstantNode(locator, index));
    299     }
    300    
    301     public static ASTNode makePending64Call(Locator locator, int index, Context context) {
    302         return Generators.makeFuncCallNode(
    303                 locator,
    304                 context.getCarrySetIdentifier(),
    305                 context.getCarrySetEncoder().getName(CarrySetBuiltin.PENDING64),
    306                 Generators.makeIntegerConstantNode(locator, index));
    307     }
    308        
    309     public static FuncCallNode makeCarryDeclare(Locator location, int carry1Count,
    310             int carryNCount, Context localContext) {
    311        
    312         IdentifierNode localCarrySetIdentifierNode = localContext.carrySetIdentifierNode(location);
    313        
    314         FuncCallNode carryDeclare = Generators.makeFuncCallNode(
    315                             location,
    316                             localContext.getCode(CarrySetBuiltin.CARRYDECLARE),
    317                             localCarrySetIdentifierNode, leaf(carry1Count, location), leaf(carryNCount, location));
    318         return carryDeclare;
    319     }
     264
     265    ///////////////////////////////////////////////////////////////////
     266    // Carry builtin calls // TODO - KH : move to PabloB.Generators
    320267    public static FuncCallNode makeLocalCarryCombine(Locator locator, int carryBase,
    321268            int carry1Count, Context localContext) {
     
    334281
    335282    }
    336     public static FuncCallNode makeLocalCarryDeclare(Locator location, int carry1Count,
    337             int carryNCount, Context localContext, Context context) {
     283    public static FuncCallNode makeLocalCarryDeclare(Locator location, Context context,
     284            Context localContext, int carry1Count, int carryNCount) {
    338285       
    339286        IdentifierNode localCarrySetIdentifierNode = localContext.carrySetIdentifierNode(location);
     
    345292        return carryDeclare;
    346293    }
    347     public static FuncCallNode makeLocalCarryCombine(Locator locator, int carryBase,
    348             int carry1Count, Context localContext, Context context) {
     294    public static FuncCallNode makeLocalCarryCombine(Locator locator, Context context,
     295            Context localContext, int carryBase, int carry1Count) {
    349296
    350297        IdentifierNode localCarrySetIdentifierNode = localContext.carrySetIdentifierNode(locator);
     
    361308
    362309    }
    363     public static FuncCallNode makeCarryFlip(Locator locator, int index, Context context) {
    364        
    365         ASTNode indexNode = Generators.makeIntegerConstantNode(locator, index);
    366        
    367         return Generators.makeFuncCallNode(locator,
    368                                             context.getCode(CarrySetBuiltin.CARRYFLIP),
    369                                             Generators.arguments(context.carrySetIdentifierNode(locator),
    370                                             indexNode));
    371     }
    372310   
    373311    public static BinaryOperatorNode makeBitwiseOrCarryTest(ASTNode condition,
     312            Context context,
    374313            int carryBase,
    375             int carryCount,
    376             Context context) {
     314            int carryCount) {
    377315        Locator location = (Locator)condition;
    378316       
     
    392330        return Generators.makeIntegerConstantNode(locator, n);
    393331    }   
     332
     333    //
     334    //
     335    ///////////////////////////////////////////////////////////////////
    394336   
    395337    ///////////////////////////////////////////////////////////////////
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltinTranslator.java

    r3384 r3387  
    44import static toolchain.pabloB.lang.idisa.IDISABuiltin.BITBLOCK_ANY;
    55import static toolchain.pabloB.lang.idisa.IDISABuiltin.BITBLOCK_SRLI;
     6import static toolchain.pabloB.lang.idisa.IDISABuiltin.SIMD_NOT;
    67import static toolchain.pabloB.lang.types.PrimitiveType.BITBLOCK_SIZE;
    78
    8 
    9 import java.util.ArrayList;
    109import java.util.List;
    1110
     
    1312import pabloB.inputHandler.*;
    1413import pabloB.ast.IntegerConstantNode;
    15 //import pabloS.ast.ASTNode;
    16 import pabloS.ast.FuncCallNode;
    17 //import pabloS.inputHandler.Locator;
    1814
    1915import toolchain.pabloB.ast.Accessors;
     
    2218import toolchain.pabloS.lang.BuiltinCallUtil;
    2319import toolchain.pabloS.lang.PabloSBuiltin;
    24 import toolchain.pabloS.transformer.visitors.infoSet.Counter;
    2520import toolchain.pabloS.transformer.visitors.pabloS2PabloB.Context;
    2621
     
    4944                    Locator locator = Generators.makeTextLocation(snode.getLocation());
    5045                       
    51                     ASTNode formatValue       = args.remove(0);
     46                    ASTNode formatValue       = args.remove(1);
    5247                    String value              = Accessors.lexeme(formatValue);
    5348                    String templateCode       = context.getCode(builtin);
     
    6358        SCANTO_TRANSLATION {
    6459        public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> args) {
     60           
     61            surroundArgWithSimdNot(snode, args.get(1));
    6562            return scanToTranslate(PabloSBuiltin.SCAN_THRU, snode, context, args);
     63        }
     64       
     65        private void surroundArgWithSimdNot(pabloS.ast.FuncCallNode snode,
     66                ASTNode arg) {
     67           
     68            Locator locator = Generators.makeTextLocation(snode.getLocation());
     69            arg.updateSelf(Generators.makeIdisaFuncCallNode(locator, SIMD_NOT, BITBLOCK_SIZE, Generators.arguments(arg)));
     70           
    6671        }
    6772    },
     
    6974    ADVANCE_THEN_SCANTO_TRANSLATION {
    7075        public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> args) {
     76           
     77            surroundArgWithSimdNot(snode, args.get(1));
    7178            return scanToTranslate(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU, snode, context, args);
     79        }
     80
     81        private void surroundArgWithSimdNot(pabloS.ast.FuncCallNode snode,
     82                ASTNode arg) {
     83           
     84            Locator locator = Generators.makeTextLocation(snode.getLocation());
     85            arg.updateSelf(Generators.makeIdisaFuncCallNode(locator, SIMD_NOT, BITBLOCK_SIZE, Generators.arguments(arg)));
     86           
    7287        }
    7388    },
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/infoSet/PropertyInfoSetMapBuilder.java

    r3385 r3387  
    4848            carry1Position = 0;
    4949            carryNPosition = 0;
    50            
    5150            carry1InitialValues = new ArrayList<Integer>();
    5251        }
    5352       
    5453        public void visitLeave(FuncDefNode node) {
    55             PropertyInfoSet propInfoSet = new PropertyInfoSet(carry1Position, carryNPosition, Carry1Count.forTree(node), CarryNCount.forTree(node), 0, 0, carry1InitialValues);
     54            PropertyInfoSet propInfoSet = new PropertyInfoSet(0, 0, Carry1Count.forTree(node), CarryNCount.forTree(node), 0, 0, carry1InitialValues); // add LA, LB
    5655            infoSetMap.put(node, propInfoSet);
    5756        }
    5857       
    59         public void visitLeave(WhileStmtNode node) {
    60             PropertyInfoSet propInfoSet = new PropertyInfoSet(carry1Position, carryNPosition, Carry1Count.forTree(node), CarryNCount.forTree(node));
     58        public void visitEnter(WhileStmtNode node) {
     59            PropertyInfoSet propInfoSet = new PropertyInfoSet(carry1Position, carryNPosition, Carry1Count.forTree(node), CarryNCount.forTree(node));  // add LA, LB
    6160            infoSetMap.put(node, propInfoSet);
    6261        }
    6362       
    64         public void visitLeave(IfStmtNode node) {
    65             PropertyInfoSet propInfoSet = new PropertyInfoSet(carry1Position, carryNPosition, Carry1Count.forTree(node), CarryNCount.forTree(node));
     63        public void visitEnter(IfStmtNode node) {
     64            PropertyInfoSet propInfoSet = new PropertyInfoSet(carry1Position, carryNPosition, Carry1Count.forTree(node), CarryNCount.forTree(node));  // add LA, LB
    6665            infoSetMap.put(node, propInfoSet);
    6766        }
    6867       
    69         public void visitLeave(FuncCallNode node) {
     68        public void visitEnter(FuncCallNode node) {
    7069           
    7170            if(BuiltinCallUtil.isCarry(node)) {
     
    7675                if(BuiltinCallUtil.isCarry1(node)) {
    7776                        carry1Position += 1;
     77                        carry1InitialValues.add(BuiltinCallUtil.builtin(node).intInitialValue());
    7878                } else if (BuiltinCallUtil.isCarryN(node)) {
    79                         System.out.println("CarryN node");
    8079                        carryNPosition += 1;
    8180                }
    82                
    83                 carry1InitialValues.add(BuiltinCallUtil.builtin(node).intInitialValue());
    8481            }
    8582        }
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/pabloS2PabloB/CarryIntroXFormer.java

    r3376 r3387  
    6464//    private static boolean isTempified = false;
    6565   
     66   
     67    // _done
    6668    private static ASTNode TempifyOnce(ASTNode ASTree) {
    6769//        if(!isTempified) {
     
    7173        return ASTree;
    7274    }
    73    
     75
     76    // _done
    7477    public static ASTNode apply(ASTNode root, PabloSBuiltinEncoder builtinEncoder, CarrySetEncoder carrySetEncoder, boolean finalBlockMode) {
    7578       
     
    7982    }
    8083
     84    // _done
    8185    private static ASTNode apply(ASTNode root, PabloSBuiltinEncoder builtinEncoder, CarrySetEncoder carrySetEncoder,
    8286                                boolean finalBlockMode, boolean ciMode, int carrySetDepth) {
     
    8589    }
    8690       
     91    // _done
    8792    private static ASTNode apply(ASTNode root, Context context) {
    8893        ASTNode xTree = TempifyOnce(root);
     
    9196        return xTree;
    9297    }
     98   
     99    // _done
    93100    private static ASTNode apply(ASTNode root, Context context, int carry1Base, int carryNBase) {
    94101       
     
    120127                        advanceNCounter.reset();
    121128                       
    122                         int carry1Count = Carry1Count.forTree(node);
    123                        
    124                         if(needsCarryAdjustment(carry1Count) ) { 
    125                                 addCarryAdjustment(node, carry1Count);
    126                         }                       
    127                        
    128                 }
    129                 public void visitLeave(FuncDefNode node) {
    130             if(context.isFinalBlockMode()) {
    131 
    132                 if(!hasEOFMaskParameter(node)) {
    133                       ParameterNode EOFMaskParameter = Generators.makeEOFMaskParameter(node, context.getBuiltinEncoder());
    134                       Generators.appendParameter(node, EOFMaskParameter);
    135                 }
    136             }
    137                 }
    138 
    139         private boolean hasEOFMaskParameter(FuncDefNode node) {
    140             if(Accessors.hasParameters(node)) {
    141                 ParameterListNode parameterList = Accessors.parameterListNode(node);
    142                 ParameterNode lastParameter = (ParameterNode)parameterList.lastChild();
    143 
    144                 final String EOF_Mask = PabloBBuiltin.EOF_MASK.pabloBName(); //context.getBuiltinEncoder().getName(PabloSBuiltin.EOF_MASK);
    145 
    146                 if(Accessors.name(lastParameter).equals(EOF_Mask)) {
    147                     return true;
    148                 }
    149             }
    150             return false;
    151         }               
    152 
    153                 private boolean needsCarryAdjustment(int carry1Count) {
    154                         return carry1Count > 0  && !context.isFinalBlockMode();
    155                 }
    156                 private void addCarryAdjustment(FuncDefNode node, int carry1Count) {
    157                         FuncCallNode carryAdjustment = makeCarryAdjustmentCall(node, carry1Count);
    158                        
    159                         ASTNode body = Accessors.body(node);
    160                         body.appendChild(carryAdjustment);
    161                 }
    162                 private FuncCallNode makeCarryAdjustmentCall(Locator location, int carry1Count) {
    163                         IntegerConstantNode carry1CountNode =  Generators.leaf(carry1Count, location);
    164                        
    165                         FuncCallNode carryAdjustment = Generators.makeFuncCallNode(
    166                                                                         location,
    167                                                                         context.getCarrySetIdentifier(),                                                                       
    168                                                                         context.getCarrySetEncoder().getName(CarrySetBuiltin.CARRYADJUST),
    169                                                                         Generators.arguments(carry1CountNode));
    170                         return carryAdjustment;
    171                 }
     129//                      int carry1Count = Carry1Count.forTree(node);
     130//                     
     131//                      if(needsCarryAdjustment(carry1Count) ) { 
     132//                              addCarryAdjustment(node, carry1Count);
     133//                      }                       
     134                       
     135                }
     136//              public void visitLeave(FuncDefNode node) {
     137//            if(context.isFinalBlockMode()) {
     138//
     139//                if(!hasEOFMaskParameter(node)) {
     140//                      ParameterNode EOFMaskParameter = Generators.makeEOFMaskParameter(node, context.getBuiltinEncoder());
     141//                      Generators.appendParameter(node, EOFMaskParameter);
     142//                }
     143//            }
     144//              }
     145
     146//        private boolean hasEOFMaskParameter(FuncDefNode node) {
     147//            if(Accessors.hasParameters(node)) {
     148//                ParameterListNode parameterList = Accessors.parameterListNode(node);
     149//                ParameterNode lastParameter = (ParameterNode)parameterList.lastChild();
     150//
     151//                final String EOF_Mask = PabloBBuiltin.EOF_MASK.pabloBName(); //context.getBuiltinEncoder().getName(PabloSBuiltin.EOF_MASK);
     152//
     153//                if(Accessors.name(lastParameter).equals(EOF_Mask)) {
     154//                    return true;
     155//                }
     156//            }
     157//            return false;
     158//        }             
     159//
     160//              private boolean needsCarryAdjustment(int carry1Count) {
     161//                      return carry1Count > 0  && !context.isFinalBlockMode();
     162//              }
     163//              private void addCarryAdjustment(FuncDefNode node, int carry1Count) {
     164//                      FuncCallNode carryAdjustment = makeCarryAdjustmentCall(node, carry1Count);
     165//                     
     166//                      ASTNode body = Accessors.body(node);
     167//                      body.appendChild(carryAdjustment);
     168//              }
     169               
     170//              private FuncCallNode makeCarryAdjustmentCall(Locator location, int carry1Count) {
     171//                      IntegerConstantNode carry1CountNode =  Generators.leaf(carry1Count, location);
     172//                     
     173//                      FuncCallNode carryAdjustment = Generators.makeFuncCallNode(
     174//                                                                      location,
     175//                                                                      context.getCarrySetIdentifier(),                                                                       
     176//                                                                      context.getCarrySetEncoder().getName(CarrySetBuiltin.CARRYADJUST),
     177//                                                                      Generators.arguments(carry1CountNode));
     178//                      return carryAdjustment;
     179//              }
    172180
    173181        ///////////////////////////////////////////////////////////////////
    174182        // AssignNode
    175                 public void visitLeave(AssignNode node) { 
    176 
    177                     ASTNode rhs = Accessors.rhs(node);
     183//              public void visitLeave(AssignNode node) { 
     184//
     185//                  ASTNode rhs = Accessors.rhs(node);
    178186//                  if(BuiltinCallUtil.isCarry(rhs)) {
    179187//                      ASTNode lhs = Accessors.lhs(node);
     
    192200//                counter.increment();
    193201//                  }
    194                 }
     202//              }
    195203           
    196204                ///////////////////////////////////////////////////////////////////
    197205                // FuncCallNode
    198206
     207               
     208                // TODO - KH: Use this routine
    199209                private static Counter selectCounter(PabloSBuiltin builtin, Counter advance1Counter, Counter advanceNCounter) {
    200210                        return builtin.isCarryN() ? advanceNCounter : advance1Counter;
     
    205215               
    206216                // current PabloS if statement implementation does not support n-bit CarryTest for Advance(x,n)
    207                 public void visitEnter(IfStmtNode node) {
    208                         assert (AdvanceNCount.forTree(node) == 0): "Advance(x,n) illegal within an if statement \n";    // should be better diagnostic
    209                        
    210                         int carryBase   = carryCounter.value();
    211                         int carry1Count = Carry1Count.forTree(node);
    212                                                
    213                         if(ifNeedsCarryProcessing(carry1Count)) {
    214                                 orCarryrangeIntoCondition(node, carryBase, carry1Count);
    215                                 appendCarryDequeueEnqueueToElseClause(node, carryBase, carry1Count);
    216                         }
    217                 }
    218                 private boolean ifNeedsCarryProcessing(int carry1Count) {
    219                         return carry1Count > 0  &&  context.isCarryInMode();
    220                 }
    221                 private void orCarryrangeIntoCondition(IfStmtNode node, int carryBase, int carry1Count) {
    222                         ASTNode condition = Accessors.condition(node);
    223                         ASTNode replacementCondition = Generators.makeBitwiseOrCarryTest(condition.deepCopy(), carryBase, carry1Count, context);
    224                        
    225                         node.replaceChild(condition, replacementCondition);
    226                 }
    227                 private void appendCarryDequeueEnqueueToElseClause(IfStmtNode node, int carryBase, int carry1Count) {
    228                         Locator location = (Locator)node;
    229                         ASTNode carryDequeueEnqueue = makeCarryDequeueEnqueue(location, carryBase, carry1Count);
    230 
    231                         ensureHasElseClause(node);     
    232                         Accessors.elseClause(node).appendChild(carryDequeueEnqueue);
    233                 }
    234                 private FuncCallNode makeCarryDequeueEnqueue(Locator location,
    235                                 int carryBase, int carry1Count) {
    236                         IntegerConstantNode carryBaseNode = Generators.leaf(carryBase, location);
    237                         IntegerConstantNode carryCountNode = Generators.leaf(carry1Count, location);
    238                        
    239                         FuncCallNode carryDequeueEnqueue = (FuncCallNode) Generators.makeFuncCallNode(
    240                                                                 location,
    241                                                                 context.getCarrySetIdentifier(),
    242                                                                 context.getCarrySetEncoder().getName(CarrySetBuiltin.CARRYDEQUEUEENQUEUE),
    243                                                                 Generators.arguments(carryBaseNode, carryCountNode));
    244                         return carryDequeueEnqueue;
    245                 }
    246                 private void ensureHasElseClause(IfStmtNode node) {
    247                         if (!Accessors.hasElseClause(node)) {   
    248                                 BlockStmtNode blockStmtNode = Generators.makeBlockStmtNode(node);
    249                                 node.appendChild(blockStmtNode);
    250                         }
    251                 }
    252 
     217//              public void visitEnter(IfStmtNode node) {
     218//                      assert (AdvanceNCount.forTree(node) == 0): "Advance(x,n) illegal within an if statement \n";    // should be better diagnostic
     219//                     
     220//                      int carryBase   = carryCounter.value();
     221//                      int carry1Count = Carry1Count.forTree(node);
     222//                                             
     223//                      if(ifNeedsCarryProcessing(carry1Count)) {
     224//                              orCarryrangeIntoCondition(node, carryBase, carry1Count);
     225//                              appendCarryDequeueEnqueueToElseClause(node, carryBase, carry1Count);
     226//                      }
     227//              }
     228//              private boolean ifNeedsCarryProcessing(int carry1Count) {
     229//                      return carry1Count > 0  &&  context.isCarryInMode();
     230//              }
     231//              private void orCarryrangeIntoCondition(IfStmtNode node, int carryBase, int carry1Count) {
     232//                      ASTNode condition = Accessors.condition(node);
     233//                      ASTNode replacementCondition = Generators.makeBitwiseOrCarryTest(condition.deepCopy(), context, carryBase, carry1Count);
     234//                     
     235//                      node.replaceChild(condition, replacementCondition);
     236//              }
     237//              private void appendCarryDequeueEnqueueToElseClause(IfStmtNode node, int carryBase, int carry1Count) {
     238//                      Locator location = (Locator)node;
     239//                      ASTNode carryDequeueEnqueue = makeCarryDequeueEnqueue(location, carryBase, carry1Count);
     240//
     241//                      ensureHasElseClause(node);     
     242//                      Accessors.elseClause(node).appendChild(carryDequeueEnqueue);
     243//              }
     244//              private FuncCallNode makeCarryDequeueEnqueue(Locator location,
     245//                              int carryBase, int carry1Count) {
     246//                      IntegerConstantNode carryBaseNode = Generators.leaf(carryBase, location);
     247//                      IntegerConstantNode carryCountNode = Generators.leaf(carry1Count, location);
     248//                     
     249//                      FuncCallNode carryDequeueEnqueue = (FuncCallNode) Generators.makeFuncCallNode(
     250//                                                              location,
     251//                                                              context.getCarrySetIdentifier(),
     252//                                                              context.getCarrySetEncoder().getName(CarrySetBuiltin.CARRYDEQUEUEENQUEUE),
     253//                                                              Generators.arguments(carryBaseNode, carryCountNode));
     254//                      return carryDequeueEnqueue;
     255//              }
     256//              private void ensureHasElseClause(IfStmtNode node) {
     257//                      if (!Accessors.hasElseClause(node)) {   
     258//                              BlockStmtNode blockStmtNode = Generators.makeBlockStmtNode(node);
     259//                              node.appendChild(blockStmtNode);
     260//                      }
     261//              }
    253262               
    254263                //   while(condition) body  =>
     
    263272               
    264273                public void visitEnter(WhileStmtNode node) {
    265                        
    266                         if(context.isFinalBlockMode()) {
    267                                 andConditionWithEOFMask(node);                                 
    268                         }
    269                        
    270                         int carry1Count         = Carry1Count.forTree(node);           
    271                         int carryNCount         = CarryNCount.forTree(node);
    272 
    273                         // TS: switched order of following two, to catch more errors.
    274                         assert (carryNCount == 0): "Advance(x,n) illegal within an if statement \n";
    275                         if(carry1Count == 0) {
    276                                 return;
    277                         }
    278                        
    279                         ASTNode replacement = makeGeneralWhileReplacement(node, carry1Count);
    280                        
    281                         node.updateSelf(replacement);   
     274// TURN OFF WHILE FOR NOW <--- Add this into the code next                     
     275//                      if(context.isFinalBlockMode()) {
     276//                              andConditionWithEOFMask(node);                                 
     277//                      }
     278//                     
     279//                      int carry1Count         = Carry1Count.forTree(node);           
     280//                      int carryNCount         = CarryNCount.forTree(node);
     281//
     282//                      // TS: switched order of following two, to catch more errors.
     283//                      assert (carryNCount == 0): "Advance(x,n) illegal within an if statement \n";
     284//                      if(carry1Count == 0) {
     285//                              return;
     286//                      }
     287//                     
     288//                      ASTNode replacement = makeGeneralWhileReplacement(node, carry1Count);
     289//                     
     290//                      node.updateSelf(replacement);   
    282291                }
    283292               
     
    330339                       
    331340                        if(context.isCarryInMode()) {
    332                                 result = Generators.makeBitwiseOrCarryTest(result, carryBase, carry1Count, context);
     341                                result = Generators.makeBitwiseOrCarryTest(result, context, carryBase, carry1Count);
    333342                        }
    334343                        return result;
     
    396405                                int carryNCount, Context localContext, Locator location) {
    397406                       
    398                         FuncCallNode carryDeclare = Generators.makeLocalCarryDeclare(location, carry1Count, carryNCount, localContext, context);
     407                        FuncCallNode carryDeclare = Generators.makeLocalCarryDeclare(location, context, localContext, carry1Count, carryNCount);
    399408                        body.insertChild(carryDeclare);
    400409                }
     
    402411                                int carry1Count, Context localContext, Locator location) {
    403412                       
    404                         FuncCallNode localCarryCombine = Generators.makeLocalCarryCombine(location, carryBase, carry1Count, localContext, context);
     413                        FuncCallNode localCarryCombine = Generators.makeLocalCarryCombine(location, context, localContext, carryBase, carry1Count);
    405414                        body.appendChild(localCarryCombine);
    406415                }
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/pabloS2PabloB/PabloS2PabloBController.java

    r3370 r3387  
    1010import toolchain.pabloS.lang.carrySet.CarrySetBuiltin2CPP;
    1111import toolchain.pabloS.lang.carrySet.CarrySetEncoder;
    12 import toolchain.pabloS.transformer.visitors.pabloS2pabloS.SurroundAssert0sWithIfs;
    1312
    1413public class PabloS2PabloBController {
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/pabloS2PabloB/PabloS2PabloBXFormer.java

    r3385 r3387  
    1717import pabloB.inputHandler.*;
    1818import pabloB.tokens.Token;
     19
    1920import toolchain.pabloB.lang.KernelState;
     21import toolchain.pabloB.lang.PabloBBuiltin;
    2022import toolchain.pabloB.ast.Accessors;
    2123import toolchain.pabloB.ast.Generators;
     
    3133import toolchain.pabloS.lang.PabloSBuiltinTranslator;
    3234
     35import toolchain.pabloS.transformer.visitors.infoSet.Carry1Count;
    3336import toolchain.pabloS.transformer.visitors.infoSet.PropertyInfoSetMapBuilder;
    3437import toolchain.pabloS.transformer.visitors.infoSet.PropertyInfoSet;
     
    3942    private static final String DO_FINAL_BLOCK    = "do_final_block";
    4043
    41     private static PabloSBuiltinEncoder builtinEncoder;
    42     private static CarrySetEncoder carrySetEncoder;
    43 
    44     Map<ASTNode, PropertyInfoSet> propertyInfoSetMap;
    45 
    46     public static void setPabloSBuiltinEncoder(PabloSBuiltinEncoder encoder) {
    47         builtinEncoder = encoder;
    48     }
    49 
    50     public static void setCarrySetEncoder(CarrySetEncoder encoder) {
    51         carrySetEncoder = encoder;
    52     }
    53 
    54     public static ASTNode apply(pabloS.ast.ASTNode pabloSASTree, pabloS.ast.ASTNode pabloSFinalBlockASTree) {
     44   
     45
     46    public static ASTNode apply(PabloSBuiltinEncoder builtinEncoder, CarrySetEncoder carrySetEncoder, pabloS.ast.ASTNode pabloSASTree, pabloS.ast.ASTNode pabloSFinalBlockASTree) {
    5547
    5648        //////////////////////////////////////////////////////////////
    5749        // Prepare
    58         Map<pabloS.ast.ASTNode, PropertyInfoSet> propInfoSetMap                         = PropertyInfoSetMapBuilder.forTree(pabloSASTree);
    59         Map<pabloS.ast.ASTNode, PropertyInfoSet> finalBlockPropInfoSetMap               = PropertyInfoSetMapBuilder.forTree(pabloSFinalBlockASTree);
    60 
    61         ASTNode pabloBASTree                = pabloSASTree.accept(new PabloS2PabloBTranslator(propInfoSetMap, false));                    // TODO - KH: context object stuff, property info set, ...
    62         ASTNode pabloBFinalBlockASTree      = pabloSFinalBlockASTree.accept(new PabloS2PabloBTranslator(finalBlockPropInfoSetMap, true));
    63 
     50       
     51        PabloS2PabloBTranslator S2BXTranslator                              = new PabloS2PabloBTranslator(pabloSASTree, builtinEncoder, carrySetEncoder, false);
     52        ASTNode pabloBASTree                                                = pabloSASTree.accept(S2BXTranslator);                   
     53
     54        PabloS2PabloBTranslator finalBlockS2BTranslator                     = new PabloS2PabloBTranslator(pabloSFinalBlockASTree, builtinEncoder, carrySetEncoder, true);
     55        ASTNode pabloBFinalBlockASTree                                      = pabloSFinalBlockASTree.accept(finalBlockS2BTranslator);
     56
     57
     58        Map<pabloS.ast.ASTNode, PropertyInfoSet> propInfoSetMap = PropertyInfoSetMapBuilder.forTree(pabloSASTree);
    6459        List<pabloS.ast.FuncDefNode> funcDefs = toolchain.pabloS.ast.Accessors.funcDefs((pabloS.ast.ProgramNode) pabloSASTree);
    6560       
    6661        for(pabloS.ast.FuncDefNode funcDef : funcDefs) {
    67 
    68             Context context = new Context(builtinEncoder,carrySetEncoder); // default context
     62           
     63            Context context = new Context(builtinEncoder, carrySetEncoder); // default context
    6964           
    7065            String kernelName = toolchain.pabloS.ast.Accessors.name(funcDef);
     
    8883           
    8984            addCarryDeclareFuncCall(locator, context, propInfoSet, kernelDef);
    90            
    9185            doBlockFuncDef.updateSelf(kernelDef);
    92            
    9386        }
    9487
     
    10295        for(int i = 0; i < values.length; i++) {   
    10396            if(values[i] > 0) {
    104                 FuncCallNode setCarryFuncCall = Generators.makeCarryFlipCall(locator, i, context);
     97                FuncCallNode setCarryFuncCall = Generators.makeCarryFlipCall(locator, context, i);
    10598                kernelDef.appendChild(setCarryFuncCall);
    10699            }
     
    111104            Context context, PropertyInfoSet propInfoSet,
    112105            KernelDefNode initDef) {
     106       
    113107        FuncCallNode carryDeclareCall = Generators.makeCarryDeclareCall(locator,
    114                 propInfoSet.carry1Count(),
    115                 propInfoSet.carryNCount(),
    116                 context);
     108                context,
     109                propInfoSet.carry1Count(),
     110                propInfoSet.carryNCount());
    117111        initDef.appendChild(carryDeclareCall);
    118112    }
    119 
    120  
    121113
    122114    private static InitDefNode makeInitDefNode(Locator locator,
     
    153145        initDef.appendChild(property);
    154146
    155         propertyName        = Generators.makeIdentifierNode(locator, KernelState.LOOK_BEHIND.name());
    156         propertyValue       = Generators.makePropertyValueNode(locator, propInfoSet.lookBehind());
    157         property            = Generators.makeKernelPropertyNode(propertyName, propertyValue);
     147        propertyName       = Generators.makeIdentifierNode(locator, KernelState.LOOK_BEHIND.name());
     148        propertyValue      = Generators.makePropertyValueNode(locator, propInfoSet.lookBehind());
     149        property           = Generators.makeKernelPropertyNode(propertyName, propertyValue);
    158150        initDef.appendChild(property);
    159151       
     
    165157    }
    166158   
     159    /*
     160     * Translates PabloS builtins and language features to PabloB.
     161     *
     162     * Translation of PabloS builtin depends upon 'final-block' and 'carry' mode.
     163     *
     164     * PabloB carry builtins are appended to the PabloB AST during the translation of PabloS to PabloB.
     165     *
     166     * PabloS if statements translate to PabloB syntax as follows.
     167     *
     168     * 'carry-in' - enabled
     169     *
     170     * if (E) { S* } => if (E | CarryTest(Position,count)) { S* }
     171     *
     172     * 'carry-in' - disabled
     173     *
     174     * if (E) { S* } => if (E) { S* }
     175     *
     176     * Carry-in mode is enabled for the initial iteration of while loops.
     177     * Carry-in mode is disabled for the translation of subsequent while loop iterations.
     178     *
     179     *
     180     * PabloS while statements translate to PabloB syntax as follows.
     181     *
     182     * 'carry-in' - enabled
     183     *
     184     * while (E) { S* } =>
     185     *
     186     * if (E | CarryTest(Position, count) )
     187     * {
     188     *      S'*
     189     *      while (E)
     190     *      {
     191     *          S''*
     192     *          CarryCombine(Position, count)
     193     *      }
     194     * }
     195     *
     196     * wherein, S'
     197     *
     198     * 'carry-in' disabled
     199     *
     200     * e.g. Nested while loops.
     201     *
     202     *
     203     * Final-block mode.
     204     *
     205     * 'And Complement' EOF_mask
     206     * ...
     207     */
     208   
    167209    private static class PabloS2PabloBTranslator extends pabloS.ast.ASTVisitor.Default<ASTNode> {
    168210
    169         private Map<pabloS.ast.ASTNode, PropertyInfoSet> infoSetMap;
     211        private Map<pabloS.ast.ASTNode, PropertyInfoSet> propInfoSetMap;
    170212        private Context context;
    171213
    172         PabloS2PabloBTranslator(Map<pabloS.ast.ASTNode, PropertyInfoSet> infoSetMap, boolean finalBlockMode) { // TODO - KH: reorganize this part, static interface, etc ...
    173 
    174             this.infoSetMap = infoSetMap;
    175 
     214        PabloS2PabloBTranslator(pabloS.ast.ASTNode root, PabloSBuiltinEncoder builtinEncoder, CarrySetEncoder carrySetEncoder, boolean finalBlockMode) {
     215            propInfoSetMap = PropertyInfoSetMapBuilder.forTree(root);
    176216            context = new Context(builtinEncoder, carrySetEncoder, true, finalBlockMode, 0);
    177217        }
     
    204244
    205245        ////////////////////////////////////////////////////////////////////////////////////
    206         // Special PabloS to PabloB translation cases.
     246        // Special PabloS to PabloB translations
    207247        //
    208 
    209         // TODO - KH: Handle field width attributes on PabloS stream types
     248       
     249        ////////////////////////////////////////////////////////////////////////////////////
     250        // FuncDef
     251        public ASTNode visitLeave(pabloS.ast.FuncDefNode snode, List<ASTNode> childResults) {
     252           
     253            ASTNode replacement = defaultVisitLeave(snode, childResults);
     254
     255            int carry1Count = propInfoSetMap.get(snode).carry1Count();
     256
     257            if(needsCarryAdjustment(carry1Count) ) { 
     258                addCarryAdjustment((FuncDefNode) replacement, carry1Count);
     259            }
     260                       
     261            if(context.isFinalBlockMode()) {
     262
     263                if(!hasEOFMaskParameter((FuncDefNode)replacement)) {
     264                    pabloB.ast.ParameterNode EOFMaskParameter = Generators.makeEOFMaskParameter(replacement);
     265                    Generators.appendParameter((FuncDefNode) replacement, EOFMaskParameter);
     266                }
     267            }
     268                       
     269            return replacement;
     270         }
     271       
     272        private boolean needsCarryAdjustment(int carry1Count) {
     273            return carry1Count > 0  && !context.isFinalBlockMode();
     274        }
     275
     276        private void addCarryAdjustment(FuncDefNode node, int carry1Count) {
     277            FuncCallNode carryAdjustment = Generators.makeCarryAdjustmentCall(node, context, carry1Count);
     278            ASTNode body = Accessors.body(node);
     279            body.appendChild(carryAdjustment);
     280        }       
     281       
     282        private boolean hasEOFMaskParameter(FuncDefNode node) {
     283            if(Accessors.hasParameters(node)) {
     284                ParameterListNode parameterList = Accessors.parameterListNode(node);
     285                ASTNode lastParameter = parameterList.lastChild();
     286
     287                final String EOF_Mask = PabloBBuiltin.EOF_MASK.pabloBName(); //context.getBuiltinEncoder().getName(PabloSBuiltin.EOF_MASK);
     288
     289                if(Accessors.name(lastParameter).equals(EOF_Mask)) {
     290                    return true;
     291                }
     292            }
     293            return false;
     294        }
     295       
     296        ////////////////////////////////////////////////////////////////////////////////////
     297        // IfStmt       
     298        public ASTNode visitLeave(pabloS.ast.IfStmtNode snode, List<ASTNode> childResults) {
     299
     300            Token pabloBToken = Generators.makeToken(snode.getToken());
     301           
     302            // TODO - KH : defaultLeaveVisit() ?
     303            IfStmtNode replacement = new IfStmtNode(pabloBToken);
     304            appendChildResults(replacement, childResults);
     305
     306            int carryNCount = propInfoSetMap.get(snode).carryNCount();
     307            assert (carryNCount == 0): "Advance(x,n) illegal within an if statement \n";    // should be better diagnostic
     308           
     309            int carry1Position  = propInfoSetMap.get(snode).carry1Position();
     310            int carry1Count     = propInfoSetMap.get(snode).carry1Count();
     311           
     312            if(ifNeedsCarryProcessing(carry1Count)) {
     313                orCarryRangeIntoCondition(replacement, carry1Position, carry1Count);
     314                appendCarryDequeueEnqueueToElseClause(replacement, carry1Position, carry1Count);
     315            }
     316           
     317            surroundConditionWithBitBlockAny(replacement, Accessors.condition(replacement));
     318           
     319            return replacement;
     320        }
     321       
     322        private boolean ifNeedsCarryProcessing(int carry1Count) {
     323            return carry1Count > 0  &&  context.isCarryInMode();
     324        }
     325                 
     326        private void orCarryRangeIntoCondition(IfStmtNode node, int carry1Position, int carry1Count) {
     327            ASTNode condition = Accessors.condition(node);
     328            ASTNode replacementCondition = Generators.makeBitwiseOrCarryTest(condition.deepCopy(), context, carry1Position, carry1Count);
     329           
     330            node.replaceChild(condition, replacementCondition);
     331        }
     332
     333        private void appendCarryDequeueEnqueueToElseClause(IfStmtNode node, int carry1Position, int carry1Count) {
     334            Locator locator = node.getLocation();
     335            ASTNode carryDequeueEnqueue = Generators.makeCarryDequeueEnqueueCall(locator, context, carry1Position, carry1Count);
     336
     337            ensureHasElseClause(node); 
     338            Accessors.elseClause(node).appendChild(carryDequeueEnqueue);
     339        }       
     340       
     341        private void ensureHasElseClause(IfStmtNode node) {
     342            if (!Accessors.hasElseClause(node)) {   
     343                BlockStmtNode blockStmtNode = Generators.makeBlockStmtNode(node);
     344                node.appendChild(blockStmtNode);
     345            }
     346        }
     347
     348        ////////////////////////////////////////////////////////////////////////////////////
     349        // WhileStmt       
     350        public ASTNode visitLeave(pabloS.ast.WhileStmtNode snode, List<ASTNode> childResults) {
     351
     352            Token pabloBToken = Generators.makeToken(snode.getToken());
     353            // TODO - KH : defaultLeaveVisit() ?
     354            WhileStmtNode replacement = new WhileStmtNode(pabloBToken);
     355            appendChildResults(replacement, childResults);
     356
     357            surroundConditionWithBitBlockAny(replacement, Accessors.condition(replacement));
     358            return replacement;
     359        }       
     360       
     361        ////////////////////////////////////////////////////////////////////////////////////
     362        // FuncCall       
     363        public ASTNode visitLeave(pabloS.ast.FuncCallNode snode, List<ASTNode> childResults) {
     364
     365            if (BuiltinCallUtil.isCarryNone(snode)) {
     366
     367                PabloSBuiltin builtin = BuiltinCallUtil.builtin(snode);
     368                PabloSBuiltinTranslator translator = builtin.getTranslator();
     369
     370                ASTNode funcCallArgsList = childResults.get(1);
     371                List<ASTNode> args = funcCallArgsList.getChildren();
     372
     373                return translator.translate(builtin, snode, context, args);
     374
     375            } else {
     376
     377                ASTNode replacement  = new FuncCallNode(Generators.makeToken(snode.getToken()));
     378                appendChildResults(replacement, childResults);
     379
     380                return replacement;
     381            }
     382        }
     383
     384        ////////////////////////////////////////////////////////////////////////////////////
     385        // AssignNode       
     386        public ASTNode visitLeave(pabloS.ast.AssignNode snode, List<ASTNode> childResults) {
     387
     388            pabloS.ast.ASTNode rhs = toolchain.pabloS.ast.Accessors.rhs(snode);
     389
     390            if(BuiltinCallUtil.isCarry(rhs)) {
     391
     392                Locator locator = Generators.makeTextLocation(snode.getLocation());
     393
     394                ASTNode funcCallArgsList = childResults.get(1).child(1);
     395                List<ASTNode> args = funcCallArgsList.getChildren();
     396
     397                ASTNode carryCall = makeCarryCall(locator, rhs);
     398                args.add(carryCall);
     399
     400                ASTNode returnValue = childResults.get(0);
     401                args.add(returnValue);
     402
     403                PabloSBuiltin builtin = BuiltinCallUtil.builtin(rhs);
     404                PabloSBuiltinTranslator translator = builtin.getTranslator();
     405                ASTNode pabloBlkFuncCall = translator.translate(builtin, (pabloS.ast.FuncCallNode) rhs, context, args);
     406
     407                ASTNode replacement = Generators.makeAssignNode(locator, carryCall, pabloBlkFuncCall);
     408
     409                return replacement;
     410
     411            } 
     412
     413            ASTNode replacement  = new AssignNode(Generators.makeToken(snode.getToken()));
     414            appendChildResults(replacement, childResults);
     415            return replacement;
     416        }
     417       
     418        private ASTNode makeCarryCall(Locator locator, pabloS.ast.ASTNode rhs) {
     419            ASTNode carryCall = null;
     420           
     421            if(BuiltinCallUtil.isCarry1(rhs)) {
     422                int carry1Position = propInfoSetMap.get(rhs).carry1Position();
     423                carryCall = Generators.makeGetCarryCall(locator, context, carry1Position);
     424
     425            } else if(BuiltinCallUtil.isCarryN(rhs)) {
     426                int carryNPosition = propInfoSetMap.get(rhs).carryNPosition();
     427                carryCall = Generators.makePending64Call(locator, context, carryNPosition);
     428            }
     429           
     430            return carryCall;
     431        }           
     432       
     433        ////////////////////////////////////////////////////////////////////////////////////
     434        // StreamType // TODO - KH: Handle field width attributes on PabloS stream types
    210435        public ASTNode visitLeave(pabloS.ast.StreamTypeNode snode, List<ASTNode> childResults) {
    211436
    212437            String lexeme = pabloB.lexicalAnalyzer.Lextant.BITBLOCK.getPrimaryLexeme();
    213438
    214             pabloB.tokens.Token bToken = pabloB.tokens.LextantToken.make(Generators.makeTextLocation(snode.getToken().getLocation()),
     439            Token bToken = pabloB.tokens.LextantToken.make(Generators.makeTextLocation(snode.getToken().getLocation()),
    215440                    lexeme,
    216441                    pabloB.lexicalAnalyzer.Lextant.forLexeme(lexeme, Generators.LEXICAL_CONTEXT));     
     
    218443            ASTNode replacement = new BitBlockTypeNode(bToken);
    219444            appendChildResults(replacement, childResults);
    220             return replacement;
    221         }
    222 
    223         public ASTNode visitLeave(pabloS.ast.FuncCallNode snode, List<ASTNode> childResults) {
    224 
    225             if (BuiltinCallUtil.isCarryNone(snode)) {
    226 
    227                 PabloSBuiltin builtin = BuiltinCallUtil.builtin(snode);
    228                 PabloSBuiltinTranslator translator = builtin.getTranslator();
    229 
    230                 ASTNode funcCallArgsList = childResults.get(1);
    231                 List<ASTNode> args = funcCallArgsList.getChildren();
    232 
    233                 return translator.translate(builtin, snode, context, args);
    234 
    235             } else {
    236 
    237                 ASTNode replacement  = new FuncCallNode(Generators.makeToken(snode.getToken()));
    238                 appendChildResults(replacement, childResults);
    239 
    240                 return replacement;
    241             }
     445           
     446            return replacement;
    242447        }
    243448
     
    250455        }
    251456
     457        ////////////////////////////////////////////////////////////////////////////////////
     458        // Bitwise / BinaryOp
    252459        public ASTNode visitLeave(pabloS.ast.BinaryOperatorNode snode, List<ASTNode> childResults) {
    253460
     
    257464
    258465            ASTNode replacement = null;
    259 
     466 
    260467            if(tokenS.isLextant(pabloS.lexicalAnalyzer.Lextant.AND, pabloS.lexicalAnalyzer.Lextant.OR, pabloS.lexicalAnalyzer.Lextant.XOR)) {
    261468
     
    283490                else if (tokenS.isLextant(pabloS.lexicalAnalyzer.Lextant.XOR)){
    284491                    replacement = Generators.makeIdisaFuncCallNode(locator, SIMD_XOR, BITBLOCK_SIZE, Generators.arguments(lhs, rhs));
    285                 } else {
    286                     assert false : "PabloS to PabloB binary operator translation not implemented.";
    287                 }
    288             }
    289 
     492                }
     493            } else {
     494                replacement = defaultVisitLeave(snode, childResults);
     495            }
    290496            return replacement;
    291497        }       
    292498
     499        ////////////////////////////////////////////////////////////////////////////////////
     500        // Bitwise / UnaryOp 
    293501        public ASTNode visitLeave(pabloS.ast.UnaryOperatorNode snode, List<ASTNode> childResults) {
    294502
    295503            pabloS.tokens.Token token = snode.getToken();
    296 
    297504            ASTNode replacement = null;
    298 
     505           
    299506            if(token.isLextant(pabloS.lexicalAnalyzer.Lextant.NOT)) {
    300                 Locator locator = Generators.makeTextLocation(snode.getLocation());
     507                Locator locator = Generators.makeTextLocation(token.getLocation());
    301508                ASTNode operand = childResults.get(0);
    302509                replacement = Generators.makeIdisaFuncCallNode(locator, SIMD_NOT, BITBLOCK_SIZE, Generators.arguments(operand));
    303510            } else {
    304                 assert false : "PabloS to PabloB unary operator translation not implemented.";
    305             }
    306 
    307             return replacement;
    308         }
    309 
    310         public ASTNode visitLeave(pabloS.ast.IfStmtNode snode, List<ASTNode> childResults) {
    311 
    312             Token pabloBToken = Generators.makeToken(snode.getToken());
    313             IfStmtNode replacement = new IfStmtNode(pabloBToken);
    314             appendChildResults(replacement, childResults);
    315 
    316             surroundConditionWithBitBlockAny(replacement, Accessors.condition(replacement));
    317             return replacement;
    318         }
    319 
    320         public ASTNode visitLeave(pabloS.ast.WhileStmtNode snode, List<ASTNode> childResults) {
    321 
    322             Token pabloBToken = Generators.makeToken(snode.getToken());
    323             WhileStmtNode replacement = new WhileStmtNode(pabloBToken);
    324             appendChildResults(replacement, childResults);
    325 
    326 
    327             surroundConditionWithBitBlockAny(replacement, Accessors.condition(replacement));
    328             return replacement;
    329         }
    330 
    331         public ASTNode visitLeave(pabloS.ast.AssignNode snode, List<ASTNode> childResults) {
    332 
    333             pabloS.ast.ASTNode rhs = toolchain.pabloS.ast.Accessors.rhs(snode);
    334 
    335             if(BuiltinCallUtil.isCarry(rhs)) {
    336 
    337                 Locator locator = Generators.makeTextLocation(snode.getLocation());
    338 
    339                 ASTNode funcCallArgsList = childResults.get(1).child(1);
    340                 List<ASTNode> args = funcCallArgsList.getChildren();
    341 
    342                 ASTNode carryCall = null;
    343                 if(BuiltinCallUtil.isCarry1(rhs)) {
    344                     int carry1Position = infoSetMap.get(rhs).carry1Position();
    345                     carryCall = Generators.makeGetCarryCall(locator, context, carry1Position);
    346 
    347                 } else if(BuiltinCallUtil.isCarryN(rhs)) {
    348                     int carryNPosition = infoSetMap.get(rhs).carryNPosition();
    349                     carryCall = Generators.makePending64Call(locator, context, carryNPosition);
    350                 }
    351 
    352                 args.add(carryCall);
    353 
    354                 ASTNode returnValue = childResults.get(0);
    355                 args.add(returnValue);
    356 
    357                 PabloSBuiltin builtin = BuiltinCallUtil.builtin(rhs);
    358                 PabloSBuiltinTranslator translator = builtin.getTranslator();
    359                 ASTNode pabloBlkFuncCall = translator.translate(builtin, (pabloS.ast.FuncCallNode) rhs, context, args);
    360 
    361                 ASTNode replacement = Generators.makeAssignNode(locator, carryCall, pabloBlkFuncCall);
    362 
    363                 return replacement;
    364 
    365             } 
    366 
    367             ASTNode replacement  = new AssignNode(Generators.makeToken(snode.getToken()));
    368             appendChildResults(replacement, childResults);
    369             return replacement;
    370         }   
    371 
    372         // helpers
     511                replacement = defaultVisitLeave(snode, childResults);
     512            }
     513            return replacement;
     514        }
     515       
     516         
     517
     518
     519
     520
     521        ////////////////////////////////////////////////////////////////////////////////////
     522        // Helpers       
    373523        private static void surroundConditionWithBitBlockAny(ASTNode node, ASTNode condition) {
    374524            Locator locator = node;
     
    377527        }
    378528    }
    379 
    380 
    381 
    382529}
    383 
Note: See TracChangeset for help on using the changeset viewer.