Changeset 3401


Ignore:
Timestamp:
Jul 12, 2013, 6:26:50 PM (6 years ago)
Author:
ksherdy
Message:

Restructured for S2S, S2B, B2B phased translation.

Location:
proto/pabloj/trunk
Files:
1 added
2 deleted
20 edited
1 moved

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/input/grammar/scatter/pabloS.scatter

    r3365 r3401  
    145145        expr    #->     expr1 ((OR^|XOR^) expr)? _leftAssoc_ ;
    146146        expr1   #-> expr2 ((AND^) expr1)? _leftAssoc_ ;
    147         expr2   #-> NOT^^* expr3;                                                                               // TODO - KH: verify '*' on 'NOT'
     147        expr2   #-> NOT^^? expr3;                                                                               // TODO - KH: verify '?' is not a '*' on expr3
    148148        expr3   #-> expr4 ((MULTIPLY^ | DIVIDE^) expr3)? _leftAssoc_ ;
    149149        expr4   #-> expr5 ((ADD^ | SUBTRACT^) expr4)? _leftAssoc_ ;
  • proto/pabloj/trunk/output/cpplang/pablo_definitions.hpp

    r3387 r3401  
    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                 while (bitblock::any(CtCDPI_Cursor))
     791                if (bitblock::any(simd_or(CtCDPI_Cursor,carry_set_0.carryRange(3,13))))
    792792                {
    793793                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
     
    868868                        }
    869869                        carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_not(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_1.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_1.getCarry(0),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_1.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_1.getCarry(1),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_1.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_1.getCarry(2),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_1.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_1.getCarry(3),_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_1.getCarry(4) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_not(PI_closer),carry_set_1.getCarry(4),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_1.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_not(CD_closer),carry_set_1.getCarry(5),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_1.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(6),Ct_Cursor));
     916                                        BitBlock Ct_error;
     917                                        Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
     918                                        BitBlock _temp3;
     919                                        carry_set_1.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(7),_temp3));
     920                                        carry_set_1.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_1.getCarry(8),Ct_Cursor));
     921                                        BitBlock _temp4;
     922                                        carry_set_1.getCarry(9) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_not(DoubleHyphen),carry_set_1.getCarry(9),_temp4));
     923                                        carry_set_1.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_1.getCarry(10),Ct_Cursor));
     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_1.getCarry(11) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_1.getCarry(11),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_1.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_not(CtCDPI_opener),carry_set_1.getCarry(12),CtCDPI_Cursor));
     938                                LocalCarryCombine(carry_set_0,carry_set_1,3,13);
     939                        }
     940                }
     941                else
     942                {
     943                        carry_set_0.carryDequeueEnqueue(3,13);
    870944                }
    871945                BitBlock _temp5;
     
    9311005                PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
    9321006                BitBlock CtCDPI_Cursor;
    933                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanToFirst(CtCDPI_opener,carry_set_0.getCarry(2),CtCDPI_Cursor));
    934                 while (bitblock::any(CtCDPI_Cursor))
     1007                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanToFirst(simd_or(CtCDPI_opener,simd_not(EOF_mask)),carry_set_0.getCarry(2),CtCDPI_Cursor));
     1008                if (bitblock::any(simd_and(simd_or(CtCDPI_Cursor,carry_set_0.carryRange(3,13)),EOF_mask)))
    9351009                {
    9361010                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
     
    9621036                                }
    9631037                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
    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));
     1038                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_andc(EOF_mask,PI_closer),carry_set_0.getCarry(7),PI_Cursor));
    9651039                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    9661040                                CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     
    9731047                        {
    9741048                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,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));
     1049                                carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_andc(EOF_mask,CD_closer),carry_set_0.getCarry(8),CD_Cursor));
    9761050                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    9771051                                CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     
    9911065                                carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_0.getCarry(11),Ct_Cursor));
    9921066                                BitBlock _temp4;
    993                                 carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_not(DoubleHyphen),carry_set_0.getCarry(12),_temp4));
     1067                                carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_andc(EOF_mask,DoubleHyphen),carry_set_0.getCarry(12),_temp4));
    9941068                                carry_set_0.getCarry(13) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_0.getCarry(13),Ct_Cursor));
    9951069                                if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
     
    10101084                                assert_0_error(simd_andc(ctCDPI_mask,EOF_mask),"Error in comment, CDATA or processing instruction syntax");
    10111085                        }
    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));
     1086                        carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),carry_set_0.getCarry(15),CtCDPI_Cursor));
     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_1.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_1.getCarry(0),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_1.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_1.getCarry(1),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_1.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_1.getCarry(2),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_1.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_1.getCarry(3),_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_1.getCarry(4) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_andc(EOF_mask,PI_closer),carry_set_1.getCarry(4),PI_Cursor));
     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_1.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_andc(EOF_mask,CD_closer),carry_set_1.getCarry(5),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_1.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(6),Ct_Cursor));
     1133                                        BitBlock Ct_error;
     1134                                        Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
     1135                                        BitBlock _temp3;
     1136                                        carry_set_1.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(7),_temp3));
     1137                                        carry_set_1.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_1.getCarry(8),Ct_Cursor));
     1138                                        BitBlock _temp4;
     1139                                        carry_set_1.getCarry(9) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_andc(EOF_mask,DoubleHyphen),carry_set_1.getCarry(9),_temp4));
     1140                                        carry_set_1.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_1.getCarry(10),Ct_Cursor));
     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_1.getCarry(11) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_1.getCarry(11),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_1.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),carry_set_1.getCarry(12),CtCDPI_Cursor));
     1155                                LocalCarryCombine(carry_set_0,carry_set_1,3,13);
     1156                        }
     1157                }
     1158                else
     1159                {
     1160                        carry_set_0.carryDequeueEnqueue(3,13);
    10131161                }
    10141162                BitBlock _temp5;
     
    10571205                        BitBlock AttNameStart;
    10581206                        AttNameStart = simd_andc(AfterWS,AttListDelim);
    1059                         while (bitblock::any(AttNameStart))
     1207                        if (bitblock::any(simd_or(AttNameStart,carry_set_0.carryRange(2,7))))
    10601208                        {
    10611209                                ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
     
    11041252                                }
    11051253                                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_1.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_1.getCarry(0),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_1.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_1.getCarry(1),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_1.getCarry(2) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_1.getCarry(2),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_1.getCarry(3) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_not(DQuoteDelim),carry_set_1.getCarry(3),DQuoteAttEnd));
     1280                                        BitBlock SQuoteAttEnd;
     1281                                        carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_not(SQuoteDelim),carry_set_1.getCarry(4),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_1.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_1.getCarry(5),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_1.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_1.getCarry(6),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,2,7);
     1301                                }
     1302                        }
     1303                        else
     1304                        {
     1305                                carry_set_0.carryDequeueEnqueue(2,7);
    11061306                        }
    11071307                }
     
    11631363                        BitBlock AttNameStart;
    11641364                        AttNameStart = simd_andc(AfterWS,AttListDelim);
    1165                         while (bitblock::any(AttNameStart))
     1365                        if (bitblock::any(simd_and(simd_or(AttNameStart,carry_set_0.carryRange(2,7)),EOF_mask)))
    11661366                        {
    11671367                                ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
     
    11881388                                SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    11891389                                BitBlock DQuoteAttEnd;
    1190                                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_not(DQuoteDelim),carry_set_0.getCarry(5),DQuoteAttEnd));
     1390                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_andc(EOF_mask,DQuoteDelim),carry_set_0.getCarry(5),DQuoteAttEnd));
    11911391                                BitBlock SQuoteAttEnd;
    1192                                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_not(SQuoteDelim),carry_set_0.getCarry(6),SQuoteAttEnd));
     1392                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_andc(EOF_mask,SQuoteDelim),carry_set_0.getCarry(6),SQuoteAttEnd));
    11931393                                BitBlock AttValEnd;
    11941394                                AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
     
    12101410                                }
    12111411                                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_1.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_1.getCarry(0),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_1.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_1.getCarry(1),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_1.getCarry(2) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_1.getCarry(2),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_1.getCarry(3) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_andc(EOF_mask,DQuoteDelim),carry_set_1.getCarry(3),DQuoteAttEnd));
     1438                                        BitBlock SQuoteAttEnd;
     1439                                        carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_andc(EOF_mask,SQuoteDelim),carry_set_1.getCarry(4),SQuoteAttEnd));
     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_1.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_1.getCarry(5),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_1.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_1.getCarry(6),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,2,7);
     1459                                }
     1460                        }
     1461                        else
     1462                        {
     1463                                carry_set_0.carryDequeueEnqueue(2,7);
    12121464                        }
    12131465                }
  • proto/pabloj/trunk/src/application/generators/ApplicationGenerator.java

    r3387 r3401  
    1313import toolchain.pabloB.transformer.visitors.pabloB2PabloB.PabloB2PabloBController;
    1414
    15 import toolchain.pabloS.transformer.visitors.pabloS2PabloB.PabloS2PabloBController;
    16 import toolchain.pabloS.transformer.visitors.pabloS2PabloB.PabloS2PabloBXFormer;
     15import toolchain.pabloS.transformer.visitors.pabloS2PabloB.PabloS2PabloBTransformer;
    1716import toolchain.pabloS.transformer.visitors.pabloS2pabloS.PabloS2SPabloController;
    1817
     
    7372                        pabloS.ast.ASTNode finalBlockDecoratedTree   = PabloS2SPabloController.accept(pabloSAST);
    7473                                               
    75                         // Transform PabloS global functions in non-final block mode
    76                         decoratedTree = PabloS2PabloBController.accept(decoratedTree);                       // <-- delete with S2B impl
    77                        
    78             // Transform PabloS global functions in final block mode
    79                         PabloS2PabloBController.setFinalBlockMode(true);                                     // <-- delete with S2B impl
    80                         finalBlockDecoratedTree = PabloS2PabloBController.accept(finalBlockDecoratedTree);   // <-- delete with S2B impl
    81                        
    8274            //////////////////////////////////////////////////////////////
    8375            // PabloS to PabloB transformation
    84                         pabloBAST = PabloS2PabloBXFormer.apply(pabloSbuiltinsEncoder, carrySetEncoder, decoratedTree, finalBlockDecoratedTree);
     76                        pabloBAST = PabloS2PabloBTransformer.apply(pabloSbuiltinsEncoder, carrySetEncoder, decoratedTree, finalBlockDecoratedTree);
    8577                       
    8678                } else if (applicationConfiguration.getSource() == SourceLanguage.PABLO_B) {
  • proto/pabloj/trunk/src/pabloS/parser/Parser.java

    r3356 r3401  
    763763                result.setProductionTag(25);
    764764                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    765                 while( nowReading.isLextant(Lextant.NOT) ) {
     765                if( nowReading.isLextant(Lextant.NOT) ) {
    766766                        result.setToken(nowReading);
    767767                        allowCompression = false;
  • proto/pabloj/trunk/src/test/pabloS/PabloSTestHarness.java

    r3369 r3401  
    33 *
    44 * Useful for regression testing.
     5 *
     6 * TODO - DO NOT USE - This harness must be updated.
    57 *
    68 */
     
    2830import toolchain.pabloS.transformer.visitors.infoSet.Carry1Count;
    2931import toolchain.pabloS.transformer.visitors.infoSet.CarryNCount;
    30 import toolchain.pabloS.transformer.visitors.pabloS2PabloB.CarryIntroXFormer;
    3132import toolchain.pabloS.transformer.visitors.pabloS2PabloB.Context;
    3233import toolchain.pabloS.transformer.visitors.pabloS2pabloS.CombineAdvances;
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Accessors.java

    r3387 r3401  
    439439    }
    440440   
     441    ////////////////////////////////////////////////////////////////////////////
     442    // helpers
     443    ////////////////////////////////////////////////////////////////////////////   
    441444    public static String lexeme(ASTNode node) {
    442445        return node.getToken().getLexeme();
     
    456459//        return result;
    457460//    }
     461   
     462    public static final ASTNode NO_ENCLOSING_NODE = null;
     463
     464    public static BlockStmtNode getEnclosingBlockStmt(ASTNode node) {
     465        BlockStmtNode enclosingBlockStmt = (BlockStmtNode) getEnclosingNodeOfType(node, BlockStmtNode.class);
     466        assert enclosingBlockStmt != NO_ENCLOSING_NODE : "getEnclosingBlockStmt(node) has no ancestor of type 'BlockStmtNode'";
     467        return enclosingBlockStmt;
     468    }
     469
     470    public static ASTNode getEnclosingNodeOfType(ASTNode node, Class<?> clazz) {
     471        ASTNode current = node.getParent();
     472        while(current != NO_ENCLOSING_NODE) {
     473            if(current.getClass().isAssignableFrom(clazz)) {
     474                return current;
     475            }
     476            current = current.getParent();
     477        }
     478
     479        return NO_ENCLOSING_NODE;
     480    }   
    458481       
    459482}
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Generators.java

    r3387 r3401  
    105105        ////////////////////////////////////////////////////////////////////////////
    106106        // Kernel
     107        //
    107108        public static KernelDefNode makeKernelDef(Locator locator,
    108109                        String name,
     
    164165        //////////////////////////////////////////////////////////////////////////
    165166        // IDISA function calls
    166        
     167        //
    167168        public static IdisaFuncCallNode makeIdisaFuncCallNode(Locator locator, IDISABuiltin builtin, int fw, ASTNode... args ) {
    168169            String packageName = builtin.packageName();
     
    214215    }
    215216   
    216 
    217        
    218    
    219     ///////////////////////////////////////////////////////////////////
    220     // SIMD EOF_mask calls
    221     public static IdisaFuncCallNode makeSIMDAndEOFMaskFuncCall(Locator locator,ASTNode node) {
    222         ASTNode eofMask = makeIdentifierNode(locator, EOF_MASK.pabloBName());
    223         return Generators.makeIdisaFuncCallNode(locator, SIMD_AND, BITBLOCK_SIZE, arguments(node, eofMask));
    224     }
    225    
    226     public static IdisaFuncCallNode makeSIMDAndCEOFMaskFuncCall(Locator locator, ASTNode node) {
    227         ASTNode eofMask = makeIdentifierNode(locator, EOF_MASK.pabloBName());
    228         return Generators.makeIdisaFuncCallNode(locator, SIMD_ANDC, BITBLOCK_SIZE, arguments(node, eofMask));
    229     }
    230    
    231217    //////////////////////////////////////////////////////////////////////////
    232     // Function defs
    233    
     218    // Function definitions
     219    //
    234220    public static void appendParameter(FuncDefNode funcDefNode, ParameterNode parameterNode) {
    235221       
     
    249235    //////////////////////////////////////////////////////////////////////////
    250236    // Function calls     
     237    //
    251238    public static FuncCallNode makeFuncCallNode(Locator locator, String identifier) {       
    252239        IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier);
     
    290277        }       
    291278       
     279    //////////////////////////////////////////////////////////////////////////
     280    // Assignment
     281    // 
    292282        public static AssignNode makeAssignNode(Locator locator, ASTNode lhs, ASTNode rhs) {
    293283               
     
    300290                return assignNode;
    301291        }
    302        
     292
     293    //////////////////////////////////////////////////////////////////////////
     294    // BlockStmt
     295    // 
    303296        public static BlockStmtNode makeBlockStmtNode(Locator locator, ASTNode ...children) {
    304297            LextantToken token = Generators.makeLextantToken(locator, Lextant.LCURLY);
     
    311304        }
    312305
     306    //////////////////////////////////////////////////////////////////////////
     307    // IfStmt
     308    // 
    313309        public static IfStmtNode makeIfStmtNode(Locator locator, ASTNode expression, BlockStmtNode ifBlockStmt, BlockStmtNode elseBlockStmt) {
    314310            IfStmtNode ifStmtNode = makeIfStmtNode(locator, expression, ifBlockStmt);
     
    374370            return integerConstantNode;
    375371        }       
    376        
    377372        public static IntConstantToken makeIntegerConstantToken(Locator locator,  int n) {
    378373                return (IntConstantToken) IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locator.getLocation(), n);
    379374        }                       
    380        
    381375    public static StringConstantNode makeStringConstantNode(Locator locator, String string) {
    382376        StringConstantToken newToken = makeStringConstantToken(locator, string);
    383377        return new StringConstantNode(newToken);
    384378    }
    385        
    386379    public static StringConstantToken makeStringConstantToken(Locator locator, String string) {
    387380        return StringConstantToken.make(LexicalType.STRING, locator, string);
     
    389382   
    390383    ///////////////////////////////////////////////////////////////////
    391     // Carry builtins   
     384    // SIMD EOF_mask calls
     385    //
     386    public static IdisaFuncCallNode makeExprAndEofMaskCall(Locator locator, ASTNode expr) {
     387        ASTNode eofMask = makeIdentifierNode(locator, EOF_MASK.pabloBName());
     388        return Generators.makeIdisaFuncCallNode(locator, SIMD_AND, BITBLOCK_SIZE, arguments(expr, eofMask));
     389    }
     390   
     391    public static IdisaFuncCallNode makeExprOrNotEofMaskCall(Locator locator, ASTNode expr) {
     392        ASTNode eofMask = makeIdentifierNode(locator, EOF_MASK.pabloBName());
     393        return Generators.makeIdisaFuncCallNode(locator, SIMD_OR, BITBLOCK_SIZE, arguments(expr,
     394                Generators.makeIdisaFuncCallNode(locator, SIMD_NOT, BITBLOCK_SIZE, arguments(eofMask))));
     395    }   
     396   
     397    public static IdisaFuncCallNode makeExprAndCEofMaskCall(Locator locator, ASTNode expr) {
     398        ASTNode eofMask = makeIdentifierNode(locator, EOF_MASK.pabloBName());
     399        return Generators.makeIdisaFuncCallNode(locator, SIMD_ANDC, BITBLOCK_SIZE, arguments(expr, eofMask));
     400    }
     401   
     402    public static IdisaFuncCallNode makeEofMaskAndCExprCall(Locator locator, ASTNode expr) {
     403        ASTNode eofMask = makeIdentifierNode(locator, EOF_MASK.pabloBName());
     404        return Generators.makeIdisaFuncCallNode(locator, SIMD_ANDC, BITBLOCK_SIZE, arguments(eofMask, expr));
     405    }
     406   
     407    public static ParameterNode makeEofMaskParameter(Locator locator) {
     408
     409        Token parameterNodeToken = Generators.makeLextantToken(locator, pabloB.lexicalAnalyzer.Lextant.BITBLOCK);
     410        ParameterNode parameterNode = new ParameterNode(parameterNodeToken);
     411
     412        Token bitBlockTypeToken = Generators.makeLextantToken(locator, pabloB.lexicalAnalyzer.Lextant.BITBLOCK);
     413        BitBlockTypeNode streamTypeNode = new BitBlockTypeNode(bitBlockTypeToken);
     414        IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, PabloBBuiltin.EOF_MASK.pabloBName()); // encoder.getName(PabloSBuiltin.EOF_MASK));
     415
     416        parameterNode.appendChild(streamTypeNode);
     417        parameterNode.appendChild(identifierNode);
     418
     419        return parameterNode;
     420    }   
     421   
     422    ///////////////////////////////////////////////////////////////////
     423    // Carry set macro calls   
    392424    public static ASTNode makeGetCarryCall(Locator locator, Context context, int carry1Position) {
    393425        return Generators.makeFuncCallNode(
    394426                locator,
    395427                context.getCarrySetIdentifier(),
    396                 context.getCarrySetEncoder().getName(CarrySetBuiltin.GETCARRY),
     428                context.getCode(CarrySetBuiltin.GETCARRY),
    397429                Generators.makeIntegerConstantNode(locator, carry1Position));
    398430    }
     
    402434                locator,
    403435                context.getCarrySetIdentifier(),
    404                 context.getCarrySetEncoder().getName(CarrySetBuiltin.PENDING64),
     436                context.getCode(CarrySetBuiltin.PENDING64),
    405437                Generators.makeIntegerConstantNode(locator, carry1Position));
    406438    }   
     
    409441       
    410442        IntegerConstantNode indexNode = Generators.makeIntegerConstantNode(locator, carry1Position);
    411        
    412443       
    413444        FuncCallNode carryFlipFuncCall = Generators.makeFuncCallNode(locator,context.getCarrySetIdentifier(),
     
    423454   
    424455    public static IdisaFuncCallNode makeBitwiseOrCarryTest(ASTNode condition,
    425             Context context,
    426             int carry1Position,
    427             int carry1Count) {
    428        
    429         Locator locator = (Locator)condition;
     456                                                            Context context,
     457                                                            int carry1Position,
     458                                                            int carry1Count) {
     459       
     460        Locator locator = condition.getLocation();
    430461
    431462        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));
     463        ASTNode carry1CountNode     = Generators.leaf(carry1Count, locator);
     464        ASTNode carryRange          = Generators.makeFuncCallNode(  locator,
     465                                                                    context.getCarrySetIdentifier(),
     466                                                                    context.getCode(CarrySetBuiltin.CARRYRANGE),
     467                                                                    Generators.arguments(carry1PositionNode, carry1CountNode));
    438468       
    439469        return Generators.makeIdisaFuncCallNode(locator, SIMD_OR, BITBLOCK_SIZE, Generators.arguments(condition, carryRange));
    440        
    441        
    442470    }   
    443471   
     
    448476        IntegerConstantNode carryNCountNode     =   Generators.makeIntegerConstantNode(locator, carryNCount);
    449477     
    450         FuncCallNode carryDeclareFuncCall       = Generators.makeFuncCallNode(locator,
     478        FuncCallNode carryDeclareFuncCall       =   Generators.makeFuncCallNode(locator,
    451479                                                                                context.getCode(CarrySetBuiltin.CARRYDECLARE),
    452480                                                                                Generators.arguments(carrySetIdentifier,
    453481                                                                                                     carry1CountNode,
    454482                                                                                                     carryNCountNode));       
    455                                                                                    
    456483        return carryDeclareFuncCall;
    457484    }
    458485 
    459     public static FuncCallNode makeCarryAdjustmentCall(Locator location, Context context, int carry1Count) {
    460         IntegerConstantNode carry1CountNode =  Generators.leaf(carry1Count, location);
     486    public static FuncCallNode makeCarryAdjustmentCall(Locator locator, Context context, int carry1Count) {
     487        IntegerConstantNode carry1CountNode =  Generators.leaf(carry1Count, locator);
    461488
    462489        FuncCallNode carryAdjustment = Generators.makeFuncCallNode(
    463                 location,
    464                 context.getCarrySetIdentifier(),                                   
    465                 context.getCarrySetEncoder().getName(CarrySetBuiltin.CARRYADJUST),
    466                 Generators.arguments(carry1CountNode));
     490                                        locator,
     491                                        context.getCarrySetIdentifier(),                                   
     492                                        context.getCode(CarrySetBuiltin.CARRYADJUST),
     493                                        Generators.arguments(carry1CountNode));
    467494        return carryAdjustment;
    468495    }   
     
    473500        IntegerConstantNode carry1CountNode     =   Generators.makeIntegerConstantNode(locator, carry1Count);
    474501       
    475         FuncCallNode carryAdjustment = Generators.makeFuncCallNode(
    476                 locator,
    477                 context.getCarrySetIdentifier(),                                   
    478                 context.getCarrySetEncoder().getName(CarrySetBuiltin.CARRYDEQUEUEENQUEUE),
    479                 Generators.arguments(carry1PositionNode, carry1CountNode));
    480         return carryAdjustment;
     502        FuncCallNode carryDequeueEnqueue = Generators.makeFuncCallNode(
     503                                            locator,
     504                                            context.getCarrySetIdentifier(),                                   
     505                                            context.getCode(CarrySetBuiltin.CARRYDEQUEUEENQUEUE),
     506                                            Generators.arguments(carry1PositionNode, carry1CountNode));
     507        return carryDequeueEnqueue;
    481508    } 
     509   
     510    public static FuncCallNode makeLocalCarryCombineCall(Locator locator, Context context, Context localContext, int carry1Position,
     511            int carry1Count) {
     512
     513        IdentifierNode carrySetIdentifierNode       = Generators.makeIdentifierNode(locator, context.getCarrySetIdentifier());
     514        IdentifierNode localCarrySetIdentifierNode  = Generators.makeIdentifierNode(locator, localContext.getCarrySetIdentifier());
     515        ASTNode carry1PositionNode                  = leaf(carry1Position, locator);
     516        ASTNode carry1CountNode                     = leaf(carry1Count, locator);
     517
     518        return Generators.makeFuncCallNode(
     519                locator,
     520                localContext.getCode(CarrySetBuiltin.LOCALCARRYCOMBINE),
     521                                        carrySetIdentifierNode,
     522                                        localCarrySetIdentifierNode,
     523                                        carry1PositionNode,
     524                                        carry1CountNode);
     525
     526    }
    482527   
    483528    public static IntegerConstantNode leaf(int n, Locator locator) {
    484529        return Generators.makeIntegerConstantNode(locator, n);
    485530    } 
    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     }
    503531   
    504532    ///////////////////////////////////////////////////////////////////
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Mutators.java

    r3384 r3401  
    11package toolchain.pabloB.ast;
    22
     3import static toolchain.pabloB.lang.idisa.IDISABuiltin.BITBLOCK_ANY;
     4import static toolchain.pabloB.lang.types.PrimitiveType.BITBLOCK_SIZE;
    35import pabloB.ast.ASTNode;
    46import pabloB.ast.BlockStmtNode;
    57import pabloB.ast.FuncDefNode;
    68import pabloB.ast.IdentifierNode;
     9import pabloB.inputHandler.Locator;
    710
    811public class Mutators {         
    912       
    10         static public void insertStatementAfter(ASTNode node, ASTNode newNode) {
     13        public static void insertStatementAfter(ASTNode node, ASTNode newNode) {
    1114                assert node.getParent() instanceof BlockStmtNode;
    1215                insertAfter(node, newNode);
    1316        }
    1417
    15         static public void insertAfter(ASTNode node, ASTNode newNode) {
     18        public static void insertAfter(ASTNode node, ASTNode newNode) {
    1619                ASTNode parent = node.getParent();
    1720                parent.insertAfterChild(node, newNode);
    1821        }
    1922       
    20         static public void rename(FuncDefNode node, String newName) {
     23        public static void rename(FuncDefNode node, String newName) {
    2124            IdentifierNode doBlockIdentifier = Generators.makeIdentifierNode(node, newName);
    2225            node.replaceChild(Accessors.funcIdentifier(node), doBlockIdentifier);   
    2326        }
    2427
     28         public static void surroundConditionWithBitBlockAny(ASTNode node, ASTNode condition) {
     29        Locator locator = node;
     30        ASTNode replacement = Generators.makeIdisaFuncCallNode(locator, BITBLOCK_ANY, BITBLOCK_SIZE, Generators.arguments(condition.deepCopy()));
     31        node.replaceChild(condition, replacement);
     32    }
     33       
    2534}
  • proto/pabloj/trunk/src/toolchain/pabloB/lang/PabloBBuiltin.java

    r3375 r3401  
    1010      PRINT_BITBLOCK("PrintBitBlock", CarryType.None, 1),
    1111      ASSERT_BITBLOCK_ALIGN("AssertBitBlockAlign", CarryType.None, 1),
    12       EOF_MASK("EOF_mask", CarryType.None, 0);
     12      EOF_MASK("EOF_mask", CarryType.None, 0), // keywords
     13      DO_BLOCK("do_block", CarryType.None, 0),
     14      DO_FINAL_BLOCK("do_final_block", CarryType.None, 0);
    1315     
    1416      public enum CarryType{One, N, None};   
  • proto/pabloj/trunk/src/toolchain/pabloB/lang/PabloBBuiltins2C.java

    r3375 r3401  
    1414        pabloB2CCode.put(PabloBBuiltin.PRINT_BITBLOCK, "print_register<BitBlock>");
    1515        pabloB2CCode.put(PabloBBuiltin.ASSERT_BITBLOCK_ALIGN, "assert_bitblock_align");
    16         pabloB2CCode.put(PabloBBuiltin.EOF_MASK, "EOF_mask");
    17                
     16        pabloB2CCode.put(PabloBBuiltin.EOF_MASK, "EOF_mask");
     17        pabloB2CCode.put(PabloBBuiltin.DO_BLOCK, "do_block");
     18        pabloB2CCode.put(PabloBBuiltin.DO_FINAL_BLOCK, "do_final_block");
     19
    1820        for(PabloBBuiltin builtin : PabloBBuiltin.values()) {
    1921                if(!pabloB2CCode.containsKey(builtin)) {
  • proto/pabloj/trunk/src/toolchain/pabloB/lang/PabloBBuiltins2CPP.java

    r3375 r3401  
    66public class PabloBBuiltins2CPP extends BuiltinEncoder {
    77       
    8         private static Map<PabloBBuiltin, String> pabloB2CCode;
     8        private static Map<PabloBBuiltin, String> pabloB2CPPCode;
    99       
    1010    static {
    1111       
    12         pabloB2CCode = new HashMap<PabloBBuiltin, String>();
     12        pabloB2CPPCode = new HashMap<PabloBBuiltin, String>();
    1313       
    14         pabloB2CCode.put(PabloBBuiltin.PRINT_BITBLOCK, "print_register<BitBlock>");
    15         pabloB2CCode.put(PabloBBuiltin.ASSERT_BITBLOCK_ALIGN, "assert_bitblock_align");
    16         pabloB2CCode.put(PabloBBuiltin.EOF_MASK, "EOF_mask");
     14        pabloB2CPPCode.put(PabloBBuiltin.PRINT_BITBLOCK, "print_register<BitBlock>");
     15        pabloB2CPPCode.put(PabloBBuiltin.ASSERT_BITBLOCK_ALIGN, "assert_bitblock_align");
     16        pabloB2CPPCode.put(PabloBBuiltin.EOF_MASK, "EOF_mask");
     17        pabloB2CPPCode.put(PabloBBuiltin.DO_BLOCK, "do_block");
     18        pabloB2CPPCode.put(PabloBBuiltin.DO_FINAL_BLOCK, "do_final_block");
    1719               
    1820        for(PabloBBuiltin builtin : PabloBBuiltin.values()) {
    19                 if(!pabloB2CCode.containsKey(builtin)) {
     21                if(!pabloB2CPPCode.containsKey(builtin)) {
    2022                                throw new RuntimeException("PabloS builtin to C mapping not unimplemented in :" + PabloBBuiltins2C.class.getSimpleName());
    2123                }
     
    2527        @Override
    2628        public String getCode(PabloBBuiltin builtin) {
    27                 return pabloB2CCode.get(builtin);
     29                return pabloB2CPPCode.get(builtin);
    2830        }
    2931
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Accessors.java

    r3387 r3401  
    180180        // IfStmtNode
    181181        ////////////////////////////////////////////////////////////////////////////
    182 
    183182        public static ASTNode condition(IfStmtNode node) {
    184183                return (ASTNode) node.child(0);
     
    466465            return null;
    467466        }
     467       
     468    ////////////////////////////////////////////////////////////////////////////
     469    // helpers
     470    ////////////////////////////////////////////////////////////////////////////       
    468471        public static String lexeme(ASTNode node) {
    469472                return node.getToken().getLexeme();
     
    482485                }
    483486                return result;
    484         }           
     487        }
     488       
     489        public static final ASTNode NO_ENCLOSING_NODE = null;
     490       
     491        public static BlockStmtNode getEnclosingBlockStmt(ASTNode node) {
     492            BlockStmtNode enclosingBlockStmt = (BlockStmtNode) getEnclosingNodeOfType(node, BlockStmtNode.class);
     493            assert enclosingBlockStmt != NO_ENCLOSING_NODE : "getEnclosingBlockStmt(node) has no ancestor of type 'BlockStmtNode'";
     494            return enclosingBlockStmt;
     495        }
     496
     497        public static boolean hasEnclosingWhileStmt(ASTNode node) {
     498            return hasEnclosingNodeOfType(node, WhileStmtNode.class);
     499        }
     500       
     501        public static boolean hasEnclosingNodeOfType(ASTNode node, Class<?> clazz) {
     502            if(getEnclosingNodeOfType(node, clazz) != NO_ENCLOSING_NODE) {
     503                return true;
     504            } else {
     505                return false;
     506            }
     507        }
     508       
     509        public static ASTNode getEnclosingNodeOfType(ASTNode node, Class<?> clazz) {
     510            ASTNode current = node.getParent();
     511            while(current != NO_ENCLOSING_NODE) {
     512                if(current.getClass().isAssignableFrom(clazz)) {
     513                    return current;
     514                }
     515                current = current.getParent();
     516            }
     517
     518            return NO_ENCLOSING_NODE;
     519        }       
    485520}
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Generators.java

    r3387 r3401  
    1515import pabloS.lexicalAnalyzer.*;
    1616import pabloS.tokens.*;
    17 
    18 import toolchain.pabloB.lang.PabloBBuiltin;
    19 import toolchain.pabloB.lang.idisa.*;
    2017import toolchain.pabloS.lang.*;
    21 import toolchain.pabloS.lang.carrySet.CarrySetBuiltin;
    22 
    23 import toolchain.pabloS.transformer.visitors.pabloS2PabloB.Context;
    2418
    2519public class Generators {
     
    239233                return mask;
    240234        }
    241        
    242         ///////////////////////////////////////////////////////////////////
    243         // SIMD EOF_mask calls // TODO - KH : move to PabloB.Generators
    244         public static FuncCallNode makeSIMDAndEOFMaskFuncCall(ASTNode node, PabloSBuiltinEncoder encoder) {
    245                 Locator location = (Locator)node;
    246                 ASTNode eofMask = makeIdentifierNode(location, "EOF_mask");
    247                 return Generators.makeFuncCallNode(location, IDISASIMDBitwiseBuiltins.AND.Name(), arguments(node, eofMask));
    248         }               
    249 
    250         public static FuncCallNode makeSIMDAndCEOFMaskFuncCall(ASTNode node, PabloSBuiltinEncoder encoder) {
    251                 ASTNode [] args = arguments(node, Generators.makeIdentifierNode(node.getToken(), PabloBBuiltin.EOF_MASK.pabloBName()));//encoder.getName(PabloSBuiltin.EOF_MASK)));
    252                 return Generators.makeFuncCallNode(node.getToken(), IDISASIMDBitwiseBuiltins.ANDC.Name(), args);
    253         }       
    254 
    255         public static FuncCallNode makeSIMDEOFMaskAndCNodeFuncCall(ASTNode node, PabloSBuiltinEncoder encoder) {
    256                 ASTNode [] args = arguments(Generators.makeIdentifierNode(node.getToken(), "EOF_mask"), node);
    257                 return Generators.makeFuncCallNode(node.getToken(), IDISASIMDBitwiseBuiltins.ANDC.Name(), args);
    258         }               
    259        
    260         public static FuncCallNode makeSIMDNotFuncCall(ASTNode node, PabloSBuiltinEncoder encoder) {
    261                 ASTNode [] args = arguments(node);
    262                 return Generators.makeFuncCallNode(node.getToken(), IDISASIMDBitwiseBuiltins.NOT.Name(), args);
    263         }               
    264 
    265     ///////////////////////////////////////////////////////////////////
    266     // Carry builtin calls // TODO - KH : move to PabloB.Generators
    267     public static FuncCallNode makeLocalCarryCombine(Locator locator, int carryBase,
    268             int carry1Count, Context localContext) {
    269 
    270         IdentifierNode localCarrySetIdentifierNode = localContext.carrySetIdentifierNode(locator);
    271         ASTNode carryBaseNode = leaf(carryBase, locator);
    272         ASTNode carry1CountNode = leaf(carry1Count, locator);
    273        
    274         return Generators.makeFuncCallNode(
    275                     locator,
    276                     localContext.getCode(CarrySetBuiltin.LOCALCARRYCOMBINE),
    277                     Generators.arguments(localContext.carrySetIdentifierNode(locator),
    278                               localCarrySetIdentifierNode,
    279                               carryBaseNode,
    280                               carry1CountNode));
    281 
    282     }
    283     public static FuncCallNode makeLocalCarryDeclare(Locator location, Context context,
    284             Context localContext, int carry1Count, int carryNCount) {
    285        
    286         IdentifierNode localCarrySetIdentifierNode = localContext.carrySetIdentifierNode(location);
    287        
    288         FuncCallNode carryDeclare = Generators.makeFuncCallNode(
    289                             location,
    290                             context.getCode(CarrySetBuiltin.CARRYDECLARE),
    291                             localCarrySetIdentifierNode, leaf(carry1Count, location), leaf(carryNCount, location));
    292         return carryDeclare;
    293     }
    294     public static FuncCallNode makeLocalCarryCombine(Locator locator, Context context,
    295             Context localContext, int carryBase, int carry1Count) {
    296 
    297         IdentifierNode localCarrySetIdentifierNode = localContext.carrySetIdentifierNode(locator);
    298         ASTNode carryBaseNode = leaf(carryBase, locator);
    299         ASTNode carry1CountNode = leaf(carry1Count, locator);
    300        
    301         return Generators.makeFuncCallNode(
    302                     locator,
    303                     context.getCode(CarrySetBuiltin.LOCALCARRYCOMBINE),
    304                     Generators.arguments(context.carrySetIdentifierNode(locator),
    305                               localCarrySetIdentifierNode,
    306                               carryBaseNode,
    307                               carry1CountNode));
    308 
    309     }
    310    
    311     public static BinaryOperatorNode makeBitwiseOrCarryTest(ASTNode condition,
    312             Context context,
    313             int carryBase,
    314             int carryCount) {
    315         Locator location = (Locator)condition;
    316        
    317         ASTNode carryBaseNode  = Generators.leaf(carryBase, location);
    318         ASTNode carryCountNode = Generators.leaf(carryCount, location);
    319         ASTNode carryRange = Generators.makeFuncCallNode(
    320                                 location,
    321                                 context.getCarrySetIdentifier(),
    322                                 context.getCarrySetEncoder().getName(CarrySetBuiltin.CARRYRANGE),
    323                                 Generators.arguments(carryBaseNode, carryCountNode));
    324 
    325         LextantToken or = Generators.makeLextantToken(condition, Lextant.OR);
    326         return Generators.makeBinaryOperatorNode(condition, carryRange, or);
    327     }
    328    
    329     public static IntegerConstantNode leaf(int n, Locator locator) {
    330         return Generators.makeIntegerConstantNode(locator, n);
    331     }   
    332 
    333     //
    334     //
    335     ///////////////////////////////////////////////////////////////////
    336    
     235
    337236    ///////////////////////////////////////////////////////////////////
    338237    // Helpers
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltin.java

    r3384 r3401  
    1010
    1111public enum PabloSBuiltin {
    12     ADVANCE(               "Advance",             CarryType.One, CARRY_TRANSLATION,  sig_S_S()  ), // BuiltinCallUtil, CombineAdvances
    13     SCAN_TO_FIRST(         "ScanToFirst",         CarryType.One, CARRY_TRANSLATION,  sig_S_S(), InitialValue.One ),
    14     SCAN_THRU(             "ScanThru",            CarryType.One, CARRY_TRANSLATION,  sig_SS_S() ), // BuiltinTranslator
    15     SCAN_TO(               "ScanTo",              CarryType.One, SCANTO_TRANSLATION, sig_SS_S() ),
    16     SPAN_UP_TO(            "SpanUpTo",            CarryType.One, CARRY_TRANSLATION,  sig_SS_S() ),
    17     INCLUSIVE_SPAN(        "InclusiveSpan",       CarryType.One, CARRY_TRANSLATION,  sig_SS_S() ),
    18     EXCLUSIVE_SPAN(        "ExclusiveSpan",       CarryType.One, CARRY_TRANSLATION,  sig_SS_S() ),
    19     ADVANCE_THEN_SCAN_THRU("AdvanceThenScanThru", CarryType.One, CARRY_TRANSLATION,  sig_SS_S() ),
    20     ADVANCE_THEN_SCAN_TO(  "AdvanceThenScanTo",   CarryType.One, ADVANCE_THEN_SCANTO_TRANSLATION,  sig_SS_S()  ), // BuiltinTranslator
     12    ADVANCE(               "Advance",             CarryType.One, CARRY_TRANSLATION,                 sig_S_S()  ), // BuiltinCallUtil, CombineAdvances
     13    SCAN_TO_FIRST(         "ScanToFirst",         CarryType.One, SCANTO_FIRST_TRANSLATION,          sig_S_S(), InitialValue.One ),
     14    SCAN_THRU(             "ScanThru",            CarryType.One, CARRY_TRANSLATION,                 sig_SS_S() ), // BuiltinTranslator
     15    SCAN_TO(               "ScanTo",              CarryType.One, SCANTO_TRANSLATION,                sig_SS_S() ),
     16    SPAN_UP_TO(            "SpanUpTo",            CarryType.One, CARRY_TRANSLATION,                 sig_SS_S() ),
     17    INCLUSIVE_SPAN(        "InclusiveSpan",       CarryType.One, CARRY_TRANSLATION,                 sig_SS_S() ),
     18    EXCLUSIVE_SPAN(        "ExclusiveSpan",       CarryType.One, CARRY_TRANSLATION,                 sig_SS_S() ),
     19    ADVANCE_THEN_SCAN_THRU("AdvanceThenScanThru", CarryType.One, CARRY_TRANSLATION,                 sig_SS_S() ),
     20    ADVANCE_THEN_SCAN_TO(  "AdvanceThenScanTo",   CarryType.One, ADVANCE_THEN_SCANTO_TRANSLATION,   sig_SS_S()  ), // BuiltinTranslator
    2121    ADVANCE_N(    "AdvanceN",  CarryType.N,    ADVANCEN_TRANSLATION, sig_SI_S() ), // AdvNCounterVisitor   
    2222
     
    2525    IN_FILE(      "inFile",    CarryType.None, INFILE_TRANSLATION,          sig_S_S()  ),
    2626    ASSERT_ZERO(  "assert_0",  CarryType.None, ASSERT_ZERO_TRANSLATION,     sig_ST_V() ), // surroundAssert0sWithIfs   
    27 //    EOF_MASK(     "EOF_mask",  CarryType.None, CARRY_TRANSLATION,           sig_V_S()  ), // deprecated, // PabloS.ast.Generators // TODO - KH: remove STAT
    2827    NULL_BUILTIN( "NULL",      CarryType.None, CARRY_TRANSLATION,           sig_V_V()  );
    2928
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltin2CPP.java

    r3375 r3401  
    3232        pabloS2CPPCode.put(PabloSBuiltin.IN_FILE,                   "inFile");
    3333        pabloS2CPPCode.put(PabloSBuiltin.ASSERT_ZERO,               "assert_0_error"); 
    34 //        pabloS2CPPCode.put(PabloSBuiltin.EOF_MASK,                  "EOF_mask");
    3534        pabloS2CPPCode.put(PabloSBuiltin.NULL_BUILTIN,              "null_builtin_error");
    3635               
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltinTranslator.java

    r3387 r3401  
    11package toolchain.pabloS.lang;
    22
    3 import static toolchain.pabloB.lang.idisa.IDISABuiltin.SIMD_CONSTANT;
    4 import static toolchain.pabloB.lang.idisa.IDISABuiltin.BITBLOCK_ANY;
    5 import static toolchain.pabloB.lang.idisa.IDISABuiltin.BITBLOCK_SRLI;
    6 import static toolchain.pabloB.lang.idisa.IDISABuiltin.SIMD_NOT;
    73import static toolchain.pabloB.lang.types.PrimitiveType.BITBLOCK_SIZE;
     4import static toolchain.pabloB.lang.idisa.IDISABuiltin.*;
    85
    96import java.util.List;
     
    1512import toolchain.pabloB.ast.Accessors;
    1613import toolchain.pabloB.ast.Generators;
     14import toolchain.pabloB.ast.Mutators;
    1715
    18 import toolchain.pabloS.lang.BuiltinCallUtil;
    1916import toolchain.pabloS.lang.PabloSBuiltin;
    2017import toolchain.pabloS.transformer.visitors.pabloS2PabloB.Context;
    2118
    2219// BuiltinTranslators translate a builtin call from pabloS to pabloB 'pablo_blk_call' AST node
    23 
    24 // The enum values follow the Command pattern, with the benefit of the client not
    25 // having to instantiate the commands.
     20// The enum values follow the Command pattern, with the benefit of the client not having to instantiate the commands.
    2621
    2722public enum PabloSBuiltinTranslator {
     
    5651        },
    5752       
     53        SCANTO_FIRST_TRANSLATION {
     54        public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> args) {
     55            Locator locator = Generators.makeToken(snode.getToken());           
     56           
     57            if(context.isFinalBlockMode()) {
     58                args.set(0, Generators.makeExprOrNotEofMaskCall(locator, args.get(0)));
     59            }
     60           
     61            return CARRY_TRANSLATION.translate(PabloSBuiltin.SCAN_TO_FIRST, snode, context, args);
     62        }
     63        },
     64       
    5865        SCANTO_TRANSLATION {
    5966        public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> args) {
     67            Locator locator = Generators.makeToken(snode.getToken());           
    6068           
    61             surroundArgWithSimdNot(snode, args.get(1));
    62             return scanToTranslate(PabloSBuiltin.SCAN_THRU, snode, context, args);
    63         }
    64        
    65         private void surroundArgWithSimdNot(pabloS.ast.FuncCallNode snode,
    66                 ASTNode arg) {
     69            args.set(1, translateScanToArgs(locator, context, args.get(1)));
    6770           
    68             Locator locator = Generators.makeTextLocation(snode.getLocation());
    69             arg.updateSelf(Generators.makeIdisaFuncCallNode(locator, SIMD_NOT, BITBLOCK_SIZE, Generators.arguments(arg)));
    70            
     71            return CARRY_TRANSLATION.translate(PabloSBuiltin.SCAN_THRU, snode, context, args);
    7172        }
    7273    },
     
    7475    ADVANCE_THEN_SCANTO_TRANSLATION {
    7576        public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> args) {
     77            Locator locator = Generators.makeToken(snode.getToken());
    7678           
    77             surroundArgWithSimdNot(snode, args.get(1));
    78             return scanToTranslate(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU, snode, context, args);
     79            args.set(1, translateScanToArgs(locator, context, args.get(1)));   
     80           
     81            return CARRY_TRANSLATION.translate(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU, snode, context, args);
    7982        }
    8083
    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            
    87         }
    8884    },
    8985   
     
    10399            IfStmtNode replacement                  = Generators.makeIfStmtNode(locator, errorStream.deepCopy(), blockStmt);
    104100
    105             surroundConditionWithBitBlockAny(replacement, Accessors.condition(replacement));
     101            Mutators.surroundConditionWithBitBlockAny(replacement, Accessors.condition(replacement));
    106102
    107103            return replacement;
    108            
    109104        }
    110105    },
     
    115110           
    116111            if(context.isFinalBlockMode()) {
    117                 return Generators.makeSIMDAndCEOFMaskFuncCall(locator, args.get(0));
    118 
    119             } else {             
     112               
     113                return Generators.makeExprAndCEofMaskCall(locator, args.get(0));
     114            } else {
     115               
    120116                FieldWidthNode fieldWidth = Generators.makeIdisaFieldWidthNode(locator, 1);
    121117                ASTNode value = Generators.makeIntegerConstantNode(locator, 0);
     
    131127           
    132128            if(context.isFinalBlockMode()) {
    133                 return Generators.makeSIMDAndEOFMaskFuncCall(locator, args.get(0));
     129                return Generators.makeExprAndEofMaskCall(locator, args.get(0));
    134130            } else {
    135131                return args.get(0);
     
    149145    };
    150146
     147    // Interface
    151148    public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode node, Context context, List<ASTNode> args) {
    152149        assert false : "'pablo_blk_' PabloSBuiltin translate not implemented for PabloSBuitin: " + this.name();
     
    155152
    156153    // Helpers
    157    
    158     private static ASTNode scanToTranslate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> args) {
    159         pabloS.ast.ASTNode argument = toolchain.pabloS.ast.Accessors.argument(snode, 1);
    160         translateArgument(context, argument);
    161         pabloS.ast.ASTNode replacement = toolchain.pabloS.ast.Generators.makeCompoundIdentifierNode(snode,
    162                 BuiltinCallUtil.BUILTIN_PACKAGE_NAME, builtin.pabloSName());
     154    private static ASTNode translateScanToArgs(Locator locator, Context context, ASTNode arg) {
    163155
    164         snode.replaceChild(toolchain.pabloS.ast.Accessors.nameNode(snode), replacement);
    165         return CARRY_TRANSLATION.translate(builtin, snode, context, args);
     156        if(context.isFinalBlockMode()) {
     157            return Generators.makeEofMaskAndCExprCall(locator, arg.deepCopy());
     158        } else {
     159            return Generators.makeIdisaFuncCallNode(locator, SIMD_NOT, BITBLOCK_SIZE, arg.deepCopy());
     160        }
     161
    166162    }
    167    
    168     private static void translateArgument(Context context, pabloS.ast.ASTNode argument) {
    169         if(context.isFinalBlockMode()) {
    170             pabloS.ast.ASTNode replacement = toolchain.pabloS.ast.Generators.makeSIMDEOFMaskAndCNodeFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
    171             argument.updateSelf(replacement);
    172         } else {
    173             pabloS.ast.ASTNode replacement = toolchain.pabloS.ast.Generators.makeSIMDNotFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
    174             argument.updateSelf(replacement);           
    175         }
    176     }   
    177 
    178     private static void surroundConditionWithBitBlockAny(ASTNode node, ASTNode condition) {
    179         Locator locator = node;
    180         ASTNode replacement = Generators.makeIdisaFuncCallNode(locator, BITBLOCK_ANY, BITBLOCK_SIZE, Generators.arguments(condition.deepCopy()));
    181         node.replaceChild(condition, replacement);
    182     }   
    183163
    184164    private static ASTNode[] arrayFromList(List<ASTNode> list) {
    185165        return list.toArray(new ASTNode [list.size()]);
    186166    }
     167       
    187168   
    188169}
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/infoSet/PropertyInfoSet.java

    r3385 r3401  
    66public class PropertyInfoSet {
    77
    8     // members
    9     private int carry1Position;
    10     private int carry1Count;
     8    public int carry1Position;
     9    public int carry1Count;
    1110
    12     private int carryNPosition;
    13     private int carryNCount;
     11    public int carryNPosition;
     12    public int carryNCount;
    1413
    15     private int lookAhead;
    16     private int lookBehind;
     14    public List<Integer> carry1InitialValues;
    1715
    18     private List<Integer> carry1InitialValues;
    19    
    20     public PropertyInfoSet(int carry1Position, int carryNPosition) { 
    21         this(carry1Position, carryNPosition, 0, 0, 0, 0);
     16    public int lookAhead;
     17    public int lookBehind;
     18
     19    public PropertyInfoSet(int carry1Position, int carryNPosition, int carry1Count, int carryNCount, List<Integer> carry1InitialValues) { 
     20        this(carry1Position, carryNPosition, carry1Count, carryNCount, carry1InitialValues, 0, 0);
    2221    }
    2322   
    24     public PropertyInfoSet(int carry1Position, int carryNPosition, int carry1Count, int carryNCount) {
    25         this(carry1Position, carryNPosition, carry1Count, carryNCount, 0, 0);
    26     } 
    27 
    28     public PropertyInfoSet(int carry1Position, int carryNPosition, int carry1Count, int carryNCount, int lookAhead, int lookBehind) { 
    29        
    30         this(carry1Position, carryNPosition, carry1Count, carryNCount, lookAhead, lookBehind, new ArrayList<Integer>());
    31        
     23    public PropertyInfoSet(int carry1Position, int carryNPosition, int carry1Count, int carryNCount, List<Integer> carry1InitialValues, int lookAhead, int lookBehind) { 
     24        this.carry1Position         = carry1Position;
     25        this.carryNPosition         = carryNPosition;
     26        this.carry1Count            = carry1Count;
     27        this.carryNCount            = carryNCount;
     28        this.lookAhead              = lookAhead;
     29        this.lookBehind             = lookBehind;
     30        this.carry1InitialValues    = new ArrayList<Integer>();
     31        this.carry1InitialValues.addAll(carry1InitialValues);
    3232    }
    33    
    34     public PropertyInfoSet(int carry1Position, int carryNPosition, int carry1Count, int carryNCount, int lookAhead, int lookBehind, List<Integer> carry1InitialValues) { 
    35         this.carry1Position(carry1Position);
    36         this.carryNPosition(carryNPosition);
    37         this.carry1Count(carry1Count);
    38         this.carryNCount(carryNCount);
    39         this.lookAhead(lookAhead);
    40         this.lookBehind(lookBehind);
    41         this.carry1InitialValues(carry1InitialValues);
    42     }
    43    
    44     public void carry1Init(int index, int element) {
    45         carry1InitialValues().set(index, element);
    46     }
    47 
    48     public int carry1Position() {
    49         return carry1Position;
    50     }
    51 
    52     private void carry1Position(int carry1Position) {
    53         this.carry1Position = carry1Position;
    54     }
    55 
    56     public int carry1Count() {
    57         return carry1Count;
    58     }
    59 
    60     private void carry1Count(int carry1Count) {
    61         this.carry1Count = carry1Count;
    62     }
    63    
    64     public int carryNPosition() {
    65         return carryNPosition;
    66     }
    67 
    68     public void carryNPosition(int carryNPosition) {
    69         this.carryNPosition = carryNPosition;
    70     }
    71 
    72     public int carryNCount() {
    73         return carryNCount;
    74     }
    75 
    76     public void carryNCount(int carryNCount) {
    77         this.carryNCount = carryNCount;
    78     }
    79 
    80     public int lookAhead() {
    81         return lookAhead;
    82     }
    83 
    84     public void lookAhead(int lookAhead) {
    85         this.lookAhead = lookAhead;
    86     }
    87 
    88     public int lookBehind() {
    89         return lookBehind;
    90     }
    91 
    92     public void lookBehind(int lookBehind) {
    93         this.lookBehind = lookBehind;
    94     }
    95    
    96     public List<Integer> carry1InitialValues() {
    97         return carry1InitialValues;
    98     }
    99 
    100     private void carry1InitialValues(List<Integer> carry1InitialValues) {
    101         this.carry1InitialValues = carry1InitialValues;
    102     }
    103    
    10433}
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/infoSet/PropertyInfoSetMapBuilder.java

    r3387 r3401  
    1111package toolchain.pabloS.transformer.visitors.infoSet;
    1212
    13 import java.util.ArrayList;
    1413import java.util.HashMap;
    15 import java.util.List;
    1614import java.util.Map;
    1715
     
    3028    static private class PropertyInformationSetVisitor extends VoidVisitor.Default {
    3129
    32         private Map<ASTNode, PropertyInfoSet> infoSetMap;
     30        private Map<ASTNode, PropertyInfoSet> propInfoSetMap;
    3331       
    3432        private int carry1Position;
    3533        private int carryNPosition;
    36        
    37         private List<Integer> carry1InitialValues;
    38        
     34               
    3935        public Map<ASTNode, PropertyInfoSet> getPropertyInformationSet() {
    40             return infoSetMap;
     36            return propInfoSetMap;
    4137        }
    4238       
    4339        public PropertyInformationSetVisitor() {
    44             infoSetMap = new HashMap<ASTNode, PropertyInfoSet>();
     40            propInfoSetMap = new HashMap<ASTNode, PropertyInfoSet>();
    4541        }
    4642       
     
    4844            carry1Position = 0;
    4945            carryNPosition = 0;
    50             carry1InitialValues = new ArrayList<Integer>();
    5146        }
    5247       
    5348        public void visitLeave(FuncDefNode node) {
    54             PropertyInfoSet propInfoSet = new PropertyInfoSet(0, 0, Carry1Count.forTree(node), CarryNCount.forTree(node), 0, 0, carry1InitialValues); // add LA, LB
    55             infoSetMap.put(node, propInfoSet);
     49            PropertyInfoSet propInfoSet = new PropertyInfoSet(carry1Position, carryNPosition, Carry1Count.forTree(node), CarryNCount.forTree(node), Carry1InitialValues.forTree(node)); // add LA, LB
     50            propInfoSetMap.put(node, propInfoSet);
    5651        }
    5752       
    5853        public void visitEnter(WhileStmtNode node) {
    59             PropertyInfoSet propInfoSet = new PropertyInfoSet(carry1Position, carryNPosition, Carry1Count.forTree(node), CarryNCount.forTree(node));  // add LA, LB
    60             infoSetMap.put(node, propInfoSet);
     54            PropertyInfoSet propInfoSet = new PropertyInfoSet(carry1Position, carryNPosition, Carry1Count.forTree(node), CarryNCount.forTree(node), Carry1InitialValues.forTree(node));  // add LA, LB
     55            propInfoSetMap.put(node, propInfoSet);
    6156        }
    6257       
    6358        public void visitEnter(IfStmtNode node) {
    64             PropertyInfoSet propInfoSet = new PropertyInfoSet(carry1Position, carryNPosition, Carry1Count.forTree(node), CarryNCount.forTree(node));  // add LA, LB
    65             infoSetMap.put(node, propInfoSet);
     59            PropertyInfoSet propInfoSet = new PropertyInfoSet(carry1Position, carryNPosition, Carry1Count.forTree(node), CarryNCount.forTree(node), Carry1InitialValues.forTree(node));  // add LA, LB
     60            propInfoSetMap.put(node, propInfoSet);
    6661        }
    6762       
     
    7065            if(BuiltinCallUtil.isCarry(node)) {
    7166
    72                 PropertyInfoSet propInfoSet = new PropertyInfoSet(carry1Position, carryNPosition); // next values
    73                 infoSetMap.put(node, propInfoSet);
     67                PropertyInfoSet propInfoSet = new PropertyInfoSet(carry1Position, carryNPosition,  Carry1Count.forTree(node), CarryNCount.forTree(node), Carry1InitialValues.forTree(node)); // add LA, LB
     68                propInfoSetMap.put(node, propInfoSet);
    7469
    7570                if(BuiltinCallUtil.isCarry1(node)) {
    7671                        carry1Position += 1;
    77                         carry1InitialValues.add(BuiltinCallUtil.builtin(node).intInitialValue());
    7872                } else if (BuiltinCallUtil.isCarryN(node)) {
    7973                        carryNPosition += 1;
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/pabloS2PabloB/Context.java

    r3364 r3401  
    3232        }
    3333       
    34         //getters - field retrieval
     34        // getters - field retrieval
    3535        public final boolean isCarryInMode() {
    3636                return carryInMode;
     
    5555       
    5656        // compound operations
    57         public final IdentifierNode carrySetIdentifierNode(Locator location) {
    58                 return Generators.makeIdentifierNode(location, getCarrySetIdentifier());
     57        public final IdentifierNode carrySetIdentifierNode(Locator locator) {
     58                return Generators.makeIdentifierNode(locator, getCarrySetIdentifier());
    5959        }
    6060        public final String getCode(CarrySetBuiltin carrySetBuiltin) {
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/pabloS2PabloB/PabloS2PabloBTransformer.java

    r3387 r3401  
    11/*
    2  * Transforms PabloS AST to PabloB AST.
    3  *
    4  * Note: PabloB variables suffixed with 'B'. PabloS variables not suffixed.
     2 * Transforms PabloS ASTs (non-final, and final-block translation) to PabloB AST (kernels).
    53 *
    64 * @author Ken Herdy <ksherdy at sfu dot ca>
     
    2321import toolchain.pabloB.ast.Generators;
    2422import toolchain.pabloB.ast.Mutators;
     23import static toolchain.pabloB.lang.PabloBBuiltin.DO_BLOCK;
     24import static toolchain.pabloB.lang.PabloBBuiltin.DO_FINAL_BLOCK;
    2525import static toolchain.pabloB.lang.types.PrimitiveType.BITBLOCK_SIZE;
    2626import static toolchain.pabloB.lang.idisa.IDISABuiltin.*;
     
    3333import toolchain.pabloS.lang.PabloSBuiltinTranslator;
    3434
    35 import toolchain.pabloS.transformer.visitors.infoSet.Carry1Count;
    3635import toolchain.pabloS.transformer.visitors.infoSet.PropertyInfoSetMapBuilder;
    3736import toolchain.pabloS.transformer.visitors.infoSet.PropertyInfoSet;
    3837
    39 public class PabloS2PabloBXFormer {
    40 
    41     private static final String DO_BLOCK                    = "do_block";
    42     private static final String DO_FINAL_BLOCK    = "do_final_block";
    43 
    44    
     38public class PabloS2PabloBTransformer {
    4539
    4640    public static ASTNode apply(PabloSBuiltinEncoder builtinEncoder, CarrySetEncoder carrySetEncoder, pabloS.ast.ASTNode pabloSASTree, pabloS.ast.ASTNode pabloSFinalBlockASTree) {
    4741
    48         //////////////////////////////////////////////////////////////
    49         // Prepare
    50        
    51         PabloS2PabloBTranslator S2BXTranslator                              = new PabloS2PabloBTranslator(pabloSASTree, builtinEncoder, carrySetEncoder, false);
     42        // S2B
     43        Map<pabloS.ast.ASTNode, PropertyInfoSet> propInfoSetMap             = PropertyInfoSetMapBuilder.forTree(pabloSASTree);
     44        Context context                                                     = new Context(builtinEncoder, carrySetEncoder, true, false, 0);
     45        PabloS2PabloBTranslator S2BXTranslator                              = new PabloS2PabloBTranslator(propInfoSetMap, context);
    5246        ASTNode pabloBASTree                                                = pabloSASTree.accept(S2BXTranslator);                   
    5347
    54         PabloS2PabloBTranslator finalBlockS2BTranslator                     = new PabloS2PabloBTranslator(pabloSFinalBlockASTree, builtinEncoder, carrySetEncoder, true);
     48        // S2B final block mode
     49        Map<pabloS.ast.ASTNode, PropertyInfoSet> finalBlockPropInfoSetMap   = PropertyInfoSetMapBuilder.forTree(pabloSFinalBlockASTree);
     50        Context finalBlockContext                                           = new Context(builtinEncoder, carrySetEncoder, true, true, 0);
     51        PabloS2PabloBTranslator finalBlockS2BTranslator                     = new PabloS2PabloBTranslator(finalBlockPropInfoSetMap, finalBlockContext);
    5552        ASTNode pabloBFinalBlockASTree                                      = pabloSFinalBlockASTree.accept(finalBlockS2BTranslator);
    56 
    57 
    58         Map<pabloS.ast.ASTNode, PropertyInfoSet> propInfoSetMap = PropertyInfoSetMapBuilder.forTree(pabloSASTree);
     53       
    5954        List<pabloS.ast.FuncDefNode> funcDefs = toolchain.pabloS.ast.Accessors.funcDefs((pabloS.ast.ProgramNode) pabloSASTree);
    6055       
    6156        for(pabloS.ast.FuncDefNode funcDef : funcDefs) {
    6257           
    63             Context context = new Context(builtinEncoder, carrySetEncoder); // default context
    64            
    65             String kernelName = toolchain.pabloS.ast.Accessors.name(funcDef);
    66             Locator locator = Generators.makeTextLocation(funcDef.getLocation());
     58            String kernelName           = toolchain.pabloS.ast.Accessors.name(funcDef);
     59            Locator locator             = Generators.makeTextLocation(funcDef.getLocation());
    6760            PropertyInfoSet propInfoSet = propInfoSetMap.get(funcDef);
    68             InitDefNode initDef = makeInitDefNode(locator, propInfoSet);
     61            InitDefNode initDef         = makeInitDefNode(locator, propInfoSet);
    6962            addCarryInitFuncCall(locator, context, propInfoSet, initDef);
    7063           
    71             FuncDefNode doBlockFuncDef = Accessors.funcDefForName(pabloBASTree, kernelName);
     64            FuncDefNode doBlockFuncDef      = Accessors.funcDefForName(pabloBASTree, kernelName);
    7265            FuncDefNode doFinalBlockFuncDef = Accessors.funcDefForName(pabloBFinalBlockASTree, kernelName);
    7366           
    74             Mutators.rename(doBlockFuncDef, DO_BLOCK);              // <-- if not final block
    75             Mutators.rename(doFinalBlockFuncDef, DO_FINAL_BLOCK);   // <-- if final block
     67            Mutators.rename(doBlockFuncDef, DO_BLOCK.pabloBName());         
     68            Mutators.rename(doFinalBlockFuncDef, DO_FINAL_BLOCK.pabloBName());
    7669                       
    77             KernelDefNode kernelDef =
    78                     Generators.makeKernelDef(locator,
    79                             kernelName,
    80                             initDef,
    81                             doBlockFuncDef,
    82                             doFinalBlockFuncDef);
     70            KernelDefNode kernelDef     = Generators.makeKernelDef(locator,
     71                                                                    kernelName,
     72                                                                    initDef,
     73                                                                    doBlockFuncDef,
     74                                                                    doFinalBlockFuncDef);
    8375           
    8476            addCarryDeclareFuncCall(locator, context, propInfoSet, kernelDef);
     
    9284            PropertyInfoSet propInfoSet, InitDefNode kernelDef) {
    9385       
    94         Integer [] values = arrayFromList(propInfoSet.carry1InitialValues());
     86        Integer [] values = arrayFromList(propInfoSet.carry1InitialValues);
    9587        for(int i = 0; i < values.length; i++) {   
    9688            if(values[i] > 0) {
     
    10799        FuncCallNode carryDeclareCall = Generators.makeCarryDeclareCall(locator,
    108100                context,
    109                 propInfoSet.carry1Count(),
    110                 propInfoSet.carryNCount());
     101                propInfoSet.carry1Count,
     102                propInfoSet.carryNCount);
    111103        initDef.appendChild(carryDeclareCall);
    112104    }
     
    119111        // kernel properties
    120112        IdentifierNode propertyName         = Generators.makeIdentifierNode(locator, KernelState.CARRY1_INITIAL_VALUES.name());
    121         PropertyValueNode propertyValue     = Generators.makePropertyValueNode(locator, arrayFromList(propInfoSet.carry1InitialValues()));
     113        PropertyValueNode propertyValue     = Generators.makePropertyValueNode(locator, arrayFromList(propInfoSet.carry1InitialValues));
    122114        KernelPropertyNode property         = Generators.makeKernelPropertyNode(propertyName, propertyValue);
    123115        initDef.appendChild(property);
    124116
    125117        propertyName        = Generators.makeIdentifierNode(locator, KernelState.CARRY1_COUNT.name());
    126         propertyValue       = Generators.makePropertyValueNode(locator, propInfoSet.carry1Count());
     118        propertyValue       = Generators.makePropertyValueNode(locator, propInfoSet.carry1Count);
    127119        property            = Generators.makeKernelPropertyNode(propertyName, propertyValue);
    128120        initDef.appendChild(property);
     
    136128
    137129        propertyName       = Generators.makeIdentifierNode(locator, KernelState.CARRYN_COUNT.name());
    138         propertyValue      = Generators.makePropertyValueNode(locator, propInfoSet.carryNCount());
     130        propertyValue      = Generators.makePropertyValueNode(locator, propInfoSet.carryNCount);
    139131        property           = Generators.makeKernelPropertyNode(propertyName, propertyValue);
    140132        initDef.appendChild(property);
    141133
    142134        propertyName       = Generators.makeIdentifierNode(locator, KernelState.LOOK_AHEAD.name());
    143         propertyValue      = Generators.makePropertyValueNode(locator, propInfoSet.lookAhead());
     135        propertyValue      = Generators.makePropertyValueNode(locator, propInfoSet.lookAhead);
    144136        property           = Generators.makeKernelPropertyNode(propertyName, propertyValue);
    145137        initDef.appendChild(property);
    146138
    147139        propertyName       = Generators.makeIdentifierNode(locator, KernelState.LOOK_BEHIND.name());
    148         propertyValue      = Generators.makePropertyValueNode(locator, propInfoSet.lookBehind());
     140        propertyValue      = Generators.makePropertyValueNode(locator, propInfoSet.lookBehind);
    149141        property           = Generators.makeKernelPropertyNode(propertyName, propertyValue);
    150142        initDef.appendChild(property);
     
    156148        return list.toArray(new Integer [list.size()]);
    157149    }
    158    
    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      */
    208150   
    209151    private static class PabloS2PabloBTranslator extends pabloS.ast.ASTVisitor.Default<ASTNode> {
     
    212154        private Context context;
    213155
    214         PabloS2PabloBTranslator(pabloS.ast.ASTNode root, PabloSBuiltinEncoder builtinEncoder, CarrySetEncoder carrySetEncoder, boolean finalBlockMode) {
    215             propInfoSetMap = PropertyInfoSetMapBuilder.forTree(root);
    216             context = new Context(builtinEncoder, carrySetEncoder, true, finalBlockMode, 0);
     156        PabloS2PabloBTranslator(Map<pabloS.ast.ASTNode, PropertyInfoSet> propInfoSetMap, Context context) {
     157            this.propInfoSetMap = propInfoSetMap;
     158            this.context = context;
    217159        }
    218160
     
    224166            String pabloBNodeName = "pabloB.ast." + nodeName;
    225167
    226             pabloB.tokens.Token pabloBToken = Generators.makeToken(node.getToken());
     168            pabloB.tokens.Token token = Generators.makeToken(node.getToken());
    227169            try {
    228170                Class<?> pabloBNodeClass = Class.forName(pabloBNodeName);
    229171                Constructor<?> constructor = pabloBNodeClass.getConstructor(pabloB.tokens.Token.class);
    230                 ASTNode pabloBNode = (ASTNode) constructor.newInstance(pabloBToken);
     172                ASTNode pabloBNode = (ASTNode) constructor.newInstance(token);
    231173                appendChildResults(pabloBNode, childResults);
    232174                return pabloBNode;
     
    244186
    245187        ////////////////////////////////////////////////////////////////////////////////////
    246         // Special PabloS to PabloB translations
    247         //
     188        // PabloS to PabloB translation (special cases)
     189        ////////////////////////////////////////////////////////////////////////////////////
    248190       
    249191        ////////////////////////////////////////////////////////////////////////////////////
    250192        // FuncDef
     193        //
    251194        public ASTNode visitLeave(pabloS.ast.FuncDefNode snode, List<ASTNode> childResults) {
    252195           
    253196            ASTNode replacement = defaultVisitLeave(snode, childResults);
    254197
    255             int carry1Count = propInfoSetMap.get(snode).carry1Count();
    256 
    257             if(needsCarryAdjustment(carry1Count) ) { 
    258                 addCarryAdjustment((FuncDefNode) replacement, carry1Count);
     198            int carry1Count = propInfoSetMap.get(snode).carry1Count;
     199
     200            if(needsCarryAdjustment(context, carry1Count) ) { 
     201                addCarryAdjustment((FuncDefNode) replacement, context, carry1Count);
    259202            }
    260203                       
    261204            if(context.isFinalBlockMode()) {
    262 
    263205                if(!hasEOFMaskParameter((FuncDefNode)replacement)) {
    264                     pabloB.ast.ParameterNode EOFMaskParameter = Generators.makeEOFMaskParameter(replacement);
     206                    pabloB.ast.ParameterNode EOFMaskParameter = Generators.makeEofMaskParameter(replacement);
    265207                    Generators.appendParameter((FuncDefNode) replacement, EOFMaskParameter);
    266208                }
     
    270212         }
    271213       
    272         private boolean needsCarryAdjustment(int carry1Count) {
    273             return carry1Count > 0  && !context.isFinalBlockMode();
    274         }
    275 
    276         private void addCarryAdjustment(FuncDefNode node, int carry1Count) {
     214        private boolean needsCarryAdjustment(Context context, int carry1Count) {
     215            return !context.isFinalBlockMode() && carry1Count > 0;
     216        }
     217
     218        private void addCarryAdjustment(FuncDefNode node, Context context, int carry1Count) {
    277219            FuncCallNode carryAdjustment = Generators.makeCarryAdjustmentCall(node, context, carry1Count);
    278220            ASTNode body = Accessors.body(node);
     
    296238        ////////////////////////////////////////////////////////////////////////////////////
    297239        // IfStmt       
     240        //
     241        //  'carry-in' - enabled
     242        //
     243        //  if (condition) { S* } => if (Any(Or(condition, CarryTest(carry1Position, carry1Count))) { S* }
     244        //       
     245        //  'carry-in' - disabled
     246        //       
     247        //  if (condition) { S* } => if (Any(condition)) { S* }
     248        //
     249        //  Note: ANDC EOF_Mask is not applied to 'condition' because we test the position following the EOF for errors.
     250        //
    298251        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();
     252           
     253            int carryNCount = propInfoSetMap.get(snode).carryNCount;
    307254            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();
     255
     256            IfStmtNode replacement = (IfStmtNode) defaultVisitLeave(snode, childResults);
     257
     258            int carry1Count     = propInfoSetMap.get(snode).carry1Count;
     259
     260            if(ifNeedsCarryProcessing(context, carry1Count)) {
     261
     262                int carry1Position  = propInfoSetMap.get(snode).carry1Position;
     263                orCarryRangeIntoCondition(replacement, context, carry1Position, carry1Count);
     264                appendCarryDequeueEnqueueToElseClause(replacement, context, carry1Position, carry1Count);
     265            }
     266
     267            Mutators.surroundConditionWithBitBlockAny(replacement, Accessors.condition(replacement));
     268
     269            return replacement;
     270        }
     271
     272        private boolean ifNeedsCarryProcessing(Context context, int carry1Count) {
     273            return context.isCarryInMode() && carry1Count > 0;
    324274        }
    325275                 
    326         private void orCarryRangeIntoCondition(IfStmtNode node, int carry1Position, int carry1Count) {
     276        private void orCarryRangeIntoCondition(IfStmtNode node, Context context, int carry1Position, int carry1Count) {
    327277            ASTNode condition = Accessors.condition(node);
    328278            ASTNode replacementCondition = Generators.makeBitwiseOrCarryTest(condition.deepCopy(), context, carry1Position, carry1Count);
     
    331281        }
    332282
    333         private void appendCarryDequeueEnqueueToElseClause(IfStmtNode node, int carry1Position, int carry1Count) {
     283        private void appendCarryDequeueEnqueueToElseClause(IfStmtNode node, Context context, int carry1Position, int carry1Count) {
    334284            Locator locator = node.getLocation();
    335285            ASTNode carryDequeueEnqueue = Generators.makeCarryDequeueEnqueueCall(locator, context, carry1Position, carry1Count);
     
    347297
    348298        ////////////////////////////////////////////////////////////////////////////////////
    349         // WhileStmt       
     299        // WhileStmt translation       
     300        //
     301        //   if 'carry1Count' is zero
     302        //
     303        //     while(condition) body => while(condition) body
     304        //
     305        //   else if 'carry1Count' greater than zero
     306        //
     307        //     if 'carry-in' mode is disabled
     308        //
     309        //       while(condition) body =>
     310        //
     311        //       while(bitblock::any(condition')) {
     312        //           carryDeclare(localCarrySetID, carry1Count, carryNCount)
     313        //           phi(body)           
     314        //           carryCombine(carrySetID, localCarrySetID, carry1Position, carry1Count)
     315        //       }
     316        //
     317        //     else if 'carry-in' mode is enabled
     318        //
     319        //       while(condition) body  =>
     320        //
     321        //       if(bitblock::any(condition''))) {
     322        //         body
     323        //         while(bitblock::any(condition')) {
     324        //           carryDeclare(localCarrySetID, carry1Count, carryNCount)
     325        //           phi(body)           
     326        //           carryCombine(carrySetID, localCarrySetID, carry1Position, carry1Count)
     327        //         }
     328        //       }
     329        //       else {
     330        //         carryDequeEnque(carryBase, carry1Count)
     331        //       }
     332        //
     333        //   condition'      = condition ANDC EOFMask if in finalBlock mode, bitblock::Any
     334        //   condition''     = condition OR carryTest in carryIn mode, ANDC EOFMask if in finalBlock mode, bitblock::Any
     335        //   phi is recursive transform with depth+1 and carryIn=false, using localCarrySet       
     336        //
     337        //
    350338        public ASTNode visitLeave(pabloS.ast.WhileStmtNode snode, List<ASTNode> childResults) {
    351339
    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;
     340            int carryNCount = propInfoSetMap.get(snode).carryNCount;
     341            assert (carryNCount == 0): "Advance(x,n) illegal within an if statement \n";    // should be better diagnostic           
     342           
     343            ASTNode replacement         = defaultVisitLeave(snode, childResults);
     344           
     345            int carry1Count = propInfoSetMap.get(snode).carry1Count;
     346            if(ifNeedsCarryProcessing(context, carry1Count)) {
     347
     348                    ASTNode outerCondition      = Accessors.condition((WhileStmtNode) replacement);
     349                    ASTNode outerBody           = Accessors.body((WhileStmtNode) replacement);
     350                    replacement = makeGeneralWhileReplacement(snode, outerCondition, outerBody);
     351
     352                    if(context.isFinalBlockMode()) {
     353                        andConditionWithEOFMask(Accessors.condition((IfStmtNode) replacement));                   
     354                    }
     355                   
     356                    Mutators.surroundConditionWithBitBlockAny(replacement, Accessors.condition((IfStmtNode) replacement));
     357                   
     358            } else {
     359               
     360                if(context.isFinalBlockMode()) {
     361                    andConditionWithEOFMask(Accessors.condition((WhileStmtNode) replacement));                   
     362                }
     363               
     364                Mutators.surroundConditionWithBitBlockAny(replacement, Accessors.condition((WhileStmtNode) replacement));   
     365            }
     366           
     367            return replacement;
     368        }       
     369       
     370        private IfStmtNode makeGeneralWhileReplacement(pabloS.ast.WhileStmtNode snode, ASTNode condition, ASTNode body) {
     371            Locator locator = Generators.makeTextLocation(snode.getLocation());
     372
     373            int carry1Position  = propInfoSetMap.get(snode).carry1Position;
     374            int carry1Count     = propInfoSetMap.get(snode).carry1Count;
     375
     376            ASTNode outerCondition      = makeOuterIfCondition(condition, carry1Position, carry1Count);   
     377            BlockStmtNode thenClause    = outerIfThenClause(snode, condition, body, carry1Position, carry1Count);
     378            BlockStmtNode elseClause    = outerIfElseClause(snode, carry1Position, carry1Count);
     379
     380            return Generators.makeIfStmtNode(locator, outerCondition, thenClause, elseClause);
     381        }       
     382       
     383        private ASTNode makeOuterIfCondition(ASTNode condition, int carry1Position, int carry1Count) {
     384            ASTNode result = condition.deepCopy();
     385            if(carry1Count > 0) {
     386                result = Generators.makeBitwiseOrCarryTest(result, context, carry1Position, carry1Count);
     387            }
     388            return result;
     389        }         
     390       
     391        private void andConditionWithEOFMask(ASTNode condition) {
     392            Locator locator = condition.getLocation();
     393            ASTNode replacement = Generators.makeExprAndEofMaskCall(locator, condition.deepCopy());
     394            condition.updateSelf(replacement);
     395        }
     396       
     397        private BlockStmtNode outerIfThenClause(pabloS.ast.WhileStmtNode snode, ASTNode condition, ASTNode body, int carry1Position, int carry1Count) {
     398            Locator locator                     = Generators.makeTextLocation(snode.getLocation());
     399
     400            BlockStmtNode outerIfThenBlockStmt  = Generators.makeBlockStmtNode(locator, body);
     401            WhileStmtNode innerWhile            = makeInnerWhile(snode, condition, carry1Position, carry1Count);
     402            outerIfThenBlockStmt.appendChild(innerWhile);
     403
     404            return outerIfThenBlockStmt;
     405        }       
     406       
     407        private WhileStmtNode makeInnerWhile(pabloS.ast.WhileStmtNode snode, ASTNode condition, int carry1Position, int carry1Count) {
     408
     409            Locator locator = Generators.makeTextLocation(snode.getLocation());
     410
     411            Context localContext = context.incrementDepth().clearCarryIn();             
     412            pabloS.ast.BlockStmtNode sbody = toolchain.pabloS.ast.Accessors.body(snode);
     413            BlockStmtNode body = transformBody(sbody, localContext);
     414
     415            WhileStmtNode innerWhile = new WhileStmtNode(Generators.makeToken(snode.getToken()));
     416           
     417            innerWhile.appendChild(condition);
     418           
     419            if(context.isFinalBlockMode()) {
     420                andConditionWithEOFMask(Accessors.condition((WhileStmtNode) innerWhile));                   
     421            }
     422           
     423            Mutators.surroundConditionWithBitBlockAny(innerWhile, Accessors.condition((WhileStmtNode) innerWhile));
     424           
     425            innerWhile.appendChild(body);
     426           
     427            insertCarryDeclare(locator, body, localContext, carry1Count, 0); // carryNCount == 0 by assertion in visitLeave(WhileStmtNode)
     428            appendCarryCombine(locator, body, context, localContext, carry1Position, carry1Count);
     429
     430            return innerWhile;
     431        }       
     432       
     433        private BlockStmtNode transformBody(pabloS.ast.ASTNode snode, Context localContext) {
     434
     435            Map<pabloS.ast.ASTNode, PropertyInfoSet> propInfoSetMap     = PropertyInfoSetMapBuilder.forTree(snode);
     436            PabloS2PabloBTranslator S2BXTranslator                      = new PabloS2PabloBTranslator(propInfoSetMap, localContext);
     437            BlockStmtNode body                                          = (BlockStmtNode) snode.accept(S2BXTranslator); 
     438            return body;
     439        }       
     440       
     441        private BlockStmtNode outerIfElseClause(pabloS.ast.WhileStmtNode snode, int carry1Position, int carry1Count) {
     442           
     443            Locator locator                     = Generators.makeTextLocation(snode.getLocation());
     444            FuncCallNode carryDequeueEnqueue    = Generators.makeCarryDequeueEnqueueCall(locator, context, carry1Position, carry1Count);
     445            return Generators.makeBlockStmtNode(locator, carryDequeueEnqueue);
     446        }       
     447       
     448        private void insertCarryDeclare(Locator locator, ASTNode body, Context localContext, int carry1Count, int carryNCount) {
     449
     450            FuncCallNode carryDeclare = Generators.makeCarryDeclareCall(locator, localContext, carry1Count, carryNCount);
     451            body.insertChild(carryDeclare);
     452        }
     453       
     454        private void appendCarryCombine(Locator locator, ASTNode body, Context context, Context localContext, int carry1Position, int carry1Count) {
     455                       
     456            FuncCallNode localCarryCombine = Generators.makeLocalCarryCombineCall(locator, context, localContext, carry1Position, carry1Count);
     457            body.appendChild(localCarryCombine);
    359458        }       
    360459       
    361460        ////////////////////////////////////////////////////////////////////////////////////
    362461        // FuncCall       
     462        //
     463        // Translation of PabloS builtin depends on 'carry-in' mode, 'final-block' mode, and
     464        // the prior execution of the TempifyCarryBuiltinCalls transformer.
     465        //
    363466        public ASTNode visitLeave(pabloS.ast.FuncCallNode snode, List<ASTNode> childResults) {
    364467
     468            ASTNode replacement = null;
     469           
    365470            if (BuiltinCallUtil.isCarryNone(snode)) {
    366471
     
    370475                ASTNode funcCallArgsList = childResults.get(1);
    371476                List<ASTNode> args = funcCallArgsList.getChildren();
    372 
    373                 return translator.translate(builtin, snode, context, args);
    374 
     477                replacement = translator.translate(builtin, snode, context, args);
     478               
    375479            } else {
    376480
    377                 ASTNode replacement  = new FuncCallNode(Generators.makeToken(snode.getToken()));
     481                replacement  = new FuncCallNode(Generators.makeToken(snode.getToken()));
    378482                appendChildResults(replacement, childResults);
    379 
    380                 return replacement;
    381             }
     483            }
     484           
     485            return replacement;
    382486        }
    383487
     
    395499                List<ASTNode> args = funcCallArgsList.getChildren();
    396500
    397                 ASTNode carryCall = makeCarryCall(locator, rhs);
     501                ASTNode carryCall = makeCarryCall(locator, context, rhs);
    398502                args.add(carryCall);
    399503
     
    404508                PabloSBuiltinTranslator translator = builtin.getTranslator();
    405509                ASTNode pabloBlkFuncCall = translator.translate(builtin, (pabloS.ast.FuncCallNode) rhs, context, args);
    406 
    407                 ASTNode replacement = Generators.makeAssignNode(locator, carryCall, pabloBlkFuncCall);
    408 
    409                 return replacement;
     510               
     511                return Generators.makeAssignNode(locator, carryCall, pabloBlkFuncCall);
    410512
    411513            } 
     
    416518        }
    417519       
    418         private ASTNode makeCarryCall(Locator locator, pabloS.ast.ASTNode rhs) {
     520        private ASTNode makeCarryCall(Locator locator, Context context, pabloS.ast.ASTNode rhs) {
    419521            ASTNode carryCall = null;
    420522           
    421523            if(BuiltinCallUtil.isCarry1(rhs)) {
    422                 int carry1Position = propInfoSetMap.get(rhs).carry1Position();
     524                int carry1Position = propInfoSetMap.get(rhs).carry1Position;
    423525                carryCall = Generators.makeGetCarryCall(locator, context, carry1Position);
    424526
    425527            } else if(BuiltinCallUtil.isCarryN(rhs)) {
    426                 int carryNPosition = propInfoSetMap.get(rhs).carryNPosition();
     528                int carryNPosition = propInfoSetMap.get(rhs).carryNPosition;
    427529                carryCall = Generators.makePending64Call(locator, context, carryNPosition);
    428530            }
     
    437539            String lexeme = pabloB.lexicalAnalyzer.Lextant.BITBLOCK.getPrimaryLexeme();
    438540
    439             Token bToken = pabloB.tokens.LextantToken.make(Generators.makeTextLocation(snode.getToken().getLocation()),
     541            Token token = pabloB.tokens.LextantToken.make(Generators.makeTextLocation(snode.getToken().getLocation()),
    440542                    lexeme,
    441543                    pabloB.lexicalAnalyzer.Lextant.forLexeme(lexeme, Generators.LEXICAL_CONTEXT));     
    442544
    443             ASTNode replacement = new BitBlockTypeNode(bToken);
     545            ASTNode replacement = new BitBlockTypeNode(token);
    444546            appendChildResults(replacement, childResults);
    445547           
     
    513615            return replacement;
    514616        }
    515        
    516          
    517 
    518 
    519 
    520 
    521         ////////////////////////////////////////////////////////////////////////////////////
    522         // Helpers       
    523         private static void surroundConditionWithBitBlockAny(ASTNode node, ASTNode condition) {
    524             Locator locator = node;
    525             ASTNode replacement = Generators.makeIdisaFuncCallNode(locator, BITBLOCK_ANY, BITBLOCK_SIZE, Generators.arguments(condition.deepCopy()));
    526             node.replaceChild(condition, replacement);
    527         }
    528617    }
    529618}
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/pabloS2pabloS/TempifyCarrySetBuiltinCalls.java

    r3370 r3401  
    6969   
    7070        static private class Tempifier extends VoidVisitor.Default {
    71        
    72             private final ASTNode NO_ENCLOSING_BLOCK_STMT = null;
    7371           
    7472            Labeller labeller;
     
    138136                if(!(node.getParent() instanceof AssignNode)) {
    139137               
    140                     BlockStmtNode blockStmt          = getEnclosingBlockStmt(node);
     138                    BlockStmtNode blockStmt          = Accessors.getEnclosingBlockStmt(node);
    141139                    Locator locator                  = blockStmt;
    142140                    IdentifierNode name              = Generators.makeIdentifierNode(locator, labeller.newLabel());
     
    158156        private void appendTempAssignsToWhileBody(WhileStmtNode node) {
    159157            BlockStmtNode whileBody    = Accessors.body(node);
    160             BlockStmtNode blockStmt    = getEnclosingBlockStmt(node);
     158            BlockStmtNode blockStmt    = Accessors.getEnclosingBlockStmt(node);
    161159            if(enclBlockStmtTempAssigns.containsKey(blockStmt)) {
    162160                for(ASTNode tempAssign : enclBlockStmtTempAssigns.get(blockStmt)) {
     
    168166        private void appendTempDeclsToWhileBody(WhileStmtNode node) {
    169167            BlockStmtNode whileBody    = Accessors.body(node);
    170             BlockStmtNode blockStmt    = getEnclosingBlockStmt(node);
     168            BlockStmtNode blockStmt    = Accessors.getEnclosingBlockStmt(node);
    171169            if(enclBlockStmtTempDecls.containsKey(blockStmt)) {
    172170                for(ASTNode tempDecl : enclBlockStmtTempDecls.get(blockStmt)) {
     
    199197       
    200198        private void bindTempAssignToBlockStmt(ASTNode node) {
    201             BlockStmtNode blockStmt          = getEnclosingBlockStmt(node);
     199            BlockStmtNode blockStmt          = Accessors.getEnclosingBlockStmt(node);
    202200            if(enclBlockStmtTempAssigns.containsKey(blockStmt)) {
    203201                addValueToList(tempAssignsInsertionChild, blockStmt, new Pair<ASTNode, List<ASTNode>>(node, enclBlockStmtTempAssigns.get(blockStmt)));
     
    207205
    208206        private void bindTempDeclsToBlockStmt(ASTNode node) {
    209             BlockStmtNode blockStmt          = getEnclosingBlockStmt(node);
     207            BlockStmtNode blockStmt          = Accessors.getEnclosingBlockStmt(node);
    210208            if(enclBlockStmtTempDecls.containsKey(blockStmt)) {
    211209                addValueToList(tempDeclsInsertionChild, blockStmt, new Pair<ASTNode, List<ASTNode>>(node, enclBlockStmtTempDecls.get(blockStmt)));
     
    214212        }           
    215213
    216         private BlockStmtNode getEnclosingBlockStmt(ASTNode node) {
    217                 BlockStmtNode enclosingBlockStmt = (BlockStmtNode) getEnclosingNodeOfType(node, BlockStmtNode.class);
    218                 assert enclosingBlockStmt != NO_ENCLOSING_BLOCK_STMT : "getEnclosingBlockStmt(node) has no ancestor of type 'BlockStmtNode'";
    219                 return enclosingBlockStmt;
    220             }
    221 
    222             private ASTNode getEnclosingNodeOfType(ASTNode node, Class<?> clazz) {
    223                 ASTNode current = node.getParent();
    224                 while(current != NO_ENCLOSING_BLOCK_STMT) {
    225                     if(current.getClass().isAssignableFrom(clazz)) {
    226                         return current;
    227                     }
    228                     current = current.getParent();
    229                 }
    230 
    231                 return NO_ENCLOSING_BLOCK_STMT;
    232             }
    233214    }
    234215}
Note: See TracChangeset for help on using the changeset viewer.