Changeset 3375


Ignore:
Timestamp:
Jun 28, 2013, 4:54:45 PM (6 years ago)
Author:
ksherdy
Message:

Added isCarryNone(snode) builtin S2B translation.

Location:
proto/pabloj/trunk/src/toolchain
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Accessors.java

    r3368 r3375  
    155155        }                       
    156156
     157    public static int intValue(IntegerConstantNode integerConstant) {
     158        return Integer.valueOf(integerConstant.getToken().getLexeme());
     159    }
     160       
    157161        ////////////////////////////////////////////////////////////////////////////
    158162        // String Constant
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Generators.java

    r3369 r3375  
    99import pabloB.lexicalAnalyzer.LexicalType;
    1010import pabloB.tokens.IdentifierToken;
    11 
    1211import pabloB.lexicalAnalyzer.Lextant;
     12
     13
    1314import toolchain.pabloB.ast.Accessors;
     15
    1416import toolchain.pabloB.lang.idisa.IDISABuiltin;
    1517import toolchain.pabloS.lang.carrySet.CarrySetBuiltin;
    1618import toolchain.pabloS.transformer.visitors.pabloS2PabloB.Context;
     19
     20import static toolchain.pabloB.lang.PabloBBuiltin.*;
     21import static toolchain.pabloB.lang.idisa.IDISABuiltin.*;
     22import static toolchain.pabloB.lang.types.PrimitiveType.BITBLOCK_SIZE;
    1723
    1824public class Generators {
     
    162168            String packageName = builtin.packageName();
    163169            String baseName = builtin.baseName();
    164             return makeIdisaFuncCallNode(locator, packageName, baseName, fw, args);
    165     }
    166        
    167     public static IdisaFuncCallNode makeIdisaFuncCallNode(Locator locator, String packageName, String baseName, int fw, ASTNode... args ) {
     170            FieldWidthNode fieldWidth = Generators.makeIdisaFieldWidthNode(locator, fw);
     171            return makeIdisaFuncCallNode(locator, packageName, baseName, fieldWidth, args);
     172    }
     173       
     174        public static IdisaFuncCallNode makeIdisaFuncCallNode(Locator locator, IDISABuiltin builtin,  FieldWidthNode fieldWidth, ASTNode... args ) {
     175            String packageName = builtin.packageName();
     176            String baseName = builtin.baseName();
     177            return makeIdisaFuncCallNode(locator, packageName, baseName, fieldWidth, args);
     178        }
     179       
     180    public static IdisaFuncCallNode makeIdisaFuncCallNode(Locator locator, String packageName, String baseName, FieldWidthNode fieldWidth, ASTNode... args ) {
    168181        CompoundIdentifierNode identifier = Generators.makeCompoundIdentifierNode(locator, packageName, baseName);   
    169         FieldWidthNode fieldWidth = Generators.makeIdisaFieldWidthNode(locator, fw);
    170182        IdisaFuncCallNode idisaFuncCall = Generators.makeIdisaFuncCallNode(locator, identifier, fieldWidth, args);
    171183        return idisaFuncCall;
     
    201213        return fieldWidthNode;
    202214    }
     215   
     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   
    203231   
    204232    //////////////////////////////////////////////////////////////////////////
     
    335363                return (IntConstantToken) IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locator.getLocation(), n);
    336364        }                       
    337 
     365       
    338366    public static StringConstantNode makeStringConstantNode(Locator locator, String string) {
    339367        StringConstantToken newToken = makeStringConstantToken(locator, string);
     
    378406        return carryDeclareFuncCall;
    379407    }
    380 
    381408   
    382409    public static ASTNode[] arguments(ASTNode...astNodes) {
    383410        return astNodes;
    384411    }
     412
    385413}
  • proto/pabloj/trunk/src/toolchain/pabloB/lang/PabloBBuiltin.java

    r3260 r3375  
    99
    1010      PRINT_BITBLOCK("PrintBitBlock", CarryType.None, 1),
    11       ASSERT_BITBLOCK_ALIGN("AssertBitBlockAlign", CarryType.None, 1);
     11      ASSERT_BITBLOCK_ALIGN("AssertBitBlockAlign", CarryType.None, 1),
     12      EOF_MASK("EOF_mask", CarryType.None, 0);
    1213     
    1314      public enum CarryType{One, N, None};   
  • proto/pabloj/trunk/src/toolchain/pabloB/lang/PabloBBuiltins2C.java

    r3208 r3375  
    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");
    1617               
    1718        for(PabloBBuiltin builtin : PabloBBuiltin.values()) {
  • proto/pabloj/trunk/src/toolchain/pabloB/lang/PabloBBuiltins2CPP.java

    r3208 r3375  
    1313       
    1414        pabloB2CCode.put(PabloBBuiltin.PRINT_BITBLOCK, "print_register<BitBlock>");
    15         pabloB2CCode.put(PabloBBuiltin.ASSERT_BITBLOCK_ALIGN, "assert_bitblock_align");
     15        pabloB2CCode.put(PabloBBuiltin.ASSERT_BITBLOCK_ALIGN, "assert_bitblock_align");
     16        pabloB2CCode.put(PabloBBuiltin.EOF_MASK, "EOF_mask");
    1617               
    1718        for(PabloBBuiltin builtin : PabloBBuiltin.values()) {
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Generators.java

    r3359 r3375  
    1616import pabloS.tokens.*;
    1717
     18import toolchain.pabloB.lang.PabloBBuiltin;
    1819import toolchain.pabloB.lang.idisa.*;
    1920import toolchain.pabloS.lang.*;
     
    243244        public static FuncCallNode makeSIMDAndEOFMaskFuncCall(ASTNode node, PabloSBuiltinEncoder encoder) {
    244245                Locator location = (Locator)node;
    245                 ASTNode eofMask = makeIdentifierNode(location, encoder.getName(PabloSBuiltin.EOF_MASK));
     246                ASTNode eofMask = makeIdentifierNode(location, "EOF_mask");
    246247                return Generators.makeFuncCallNode(location, IDISASIMDBitwiseBuiltins.AND.Name(), arguments(node, eofMask));
    247248        }               
    248249
    249250        public static FuncCallNode makeSIMDAndCEOFMaskFuncCall(ASTNode node, PabloSBuiltinEncoder encoder) {
    250                 ASTNode [] args = arguments(node, Generators.makeIdentifierNode(node.getToken(), encoder.getName(PabloSBuiltin.EOF_MASK)));
     251                ASTNode [] args = arguments(node, Generators.makeIdentifierNode(node.getToken(), PabloBBuiltin.EOF_MASK.pabloBName()));//encoder.getName(PabloSBuiltin.EOF_MASK)));
    251252                return Generators.makeFuncCallNode(node.getToken(), IDISASIMDBitwiseBuiltins.ANDC.Name(), args);
    252253        }       
    253254
    254255        public static FuncCallNode makeSIMDEOFMaskAndCNodeFuncCall(ASTNode node, PabloSBuiltinEncoder encoder) {
    255                 ASTNode [] args = arguments(Generators.makeIdentifierNode(node.getToken(), encoder.getName(PabloSBuiltin.EOF_MASK)), node);
     256                ASTNode [] args = arguments(Generators.makeIdentifierNode(node.getToken(), "EOF_mask"), node);
    256257                return Generators.makeFuncCallNode(node.getToken(), IDISASIMDBitwiseBuiltins.ANDC.Name(), args);
    257258        }               
     
    269270                Token streamTypeToken = Generators.makeLextantToken(locator, Lextant.STREAM);
    270271                StreamTypeNode streamTypeNode = new StreamTypeNode(streamTypeToken);
    271                 IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, encoder.getName(PabloSBuiltin.EOF_MASK));
     272                IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, PabloBBuiltin.EOF_MASK.pabloBName()); // encoder.getName(PabloSBuiltin.EOF_MASK));
    272273               
    273274                parameterNode.appendChild(streamTypeNode);
     
    389390    }   
    390391   
    391    
    392392    ///////////////////////////////////////////////////////////////////
    393393    // Helpers
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/BuiltinCallUtil.java

    r3368 r3375  
    99public class BuiltinCallUtil {
    1010    public static final String BUILTIN_PACKAGE_NAME = "pablo";
    11        
     11
     12   
     13    public static boolean isAtEOF(ASTNode node) {
     14        return isBuiltInCall(node, PabloSBuiltin.AT_EOF);
     15    }
     16    public static boolean isInFile(ASTNode node) {
     17        return isBuiltInCall(node, PabloSBuiltin.IN_FILE);
     18    }
    1219    public static boolean isAssertZero(ASTNode node) {
    1320        return isBuiltInCall(node, PabloSBuiltin.ASSERT_ZERO);
    1421    }
    15    
    1622    public static boolean isMask(ASTNode node) {
    1723        return isBuiltInCall(node, PabloSBuiltin.MASK);
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltin.java

    r3348 r3375  
    1010public enum PabloSBuiltin {
    1111    ADVANCE(               "Advance",             CarryType.One, CARRY_TRANSLATION,  sig_S_S()  ), // BuiltinCallUtil, CombineAdvances
    12     SCAN_TO_FIRST(         "ScanToFirst",         CarryType.One, CARRY_TRANSLATION,  sig_S_S(),  InitialValue.One ),
     12    SCAN_TO_FIRST(         "ScanToFirst",         CarryType.One, CARRY_TRANSLATION,  sig_S_S(), InitialValue.One ),
    1313    SCAN_THRU(             "ScanThru",            CarryType.One, CARRY_TRANSLATION,  sig_SS_S() ), // BuiltinTranslator
    1414    SCAN_TO(               "ScanTo",              CarryType.One, SCANTO_TRANSLATION, sig_SS_S() ),
     
    1616    INCLUSIVE_SPAN(        "InclusiveSpan",       CarryType.One, CARRY_TRANSLATION,  sig_SS_S() ),
    1717    EXCLUSIVE_SPAN(        "ExclusiveSpan",       CarryType.One, CARRY_TRANSLATION,  sig_SS_S() ),
    18     ADVANCE_THEN_SCAN_THRU("AdvanceThenScanThru", CarryType.One, CARRY_TRANSLATION,  sig_SS_S()  ),
     18    ADVANCE_THEN_SCAN_THRU("AdvanceThenScanThru", CarryType.One, CARRY_TRANSLATION,  sig_SS_S() ),
    1919    ADVANCE_THEN_SCAN_TO(  "AdvanceThenScanTo",   CarryType.One, ADVANCE_THEN_SCANTO_TRANSLATION,  sig_SS_S()  ), // BuiltinTranslator
    2020    ADVANCE_N(    "AdvanceN",  CarryType.N,    ADVANCEN_TRANSLATION, sig_SI_S() ), // AdvNCounterVisitor   
    2121
    22     MASK(         "Mask",      CarryType.None, MASK_TRANSLATION,     sig_II_S() ), // visitors.carry.Counter   
    23     AT_EOF(       "atEOF",     CarryType.None, ATEOF_TRANSLATION,    sig_S_S()  ),
    24     IN_FILE(      "inFile",    CarryType.None, INFILE_TRANSLATION,   sig_S_S()  ),
    25     ASSERT_ZERO(  "assert_0",  CarryType.None, CARRY_TRANSLATION,    sig_ST_V() ), // surroundAssert0sWithIfs   
    26     EOF_MASK(     "EOF_mask",  CarryType.None, CARRY_TRANSLATION,    sig_V_S()  ), // deprecated, // PabloS.ast.Generators
    27     NULL_BUILTIN( "NULL",      CarryType.None, CARRY_TRANSLATION,    sig_V_V()  );
     22    MASK(         "Mask",      CarryType.None, MASK_TRANSLATION,            sig_II_S() ), // visitors.carry.Counter   
     23    AT_EOF(       "atEOF",     CarryType.None, ATEOF_TRANSLATION,           sig_S_S()  ),
     24    IN_FILE(      "inFile",    CarryType.None, INFILE_TRANSLATION,          sig_S_S()  ),
     25    ASSERT_ZERO(  "assert_0",  CarryType.None, ASSERT_ZERO_TRANSLATION,     sig_ST_V() ), // surroundAssert0sWithIfs   
     26//    EOF_MASK(     "EOF_mask",  CarryType.None, CARRY_TRANSLATION,           sig_V_S()  ), // deprecated, // PabloS.ast.Generators // TODO - KH: remove STAT
     27    NULL_BUILTIN( "NULL",      CarryType.None, CARRY_TRANSLATION,           sig_V_V()  );
    2828
    2929    public enum CarryType{One, N, None};
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltin2C.java

    r3345 r3375  
    2626        pabloS2CCode.put(PabloSBuiltin.IN_FILE,                 "inFile");
    2727        pabloS2CCode.put(PabloSBuiltin.ASSERT_ZERO,             "assert_0_error");     
    28         pabloS2CCode.put(PabloSBuiltin.EOF_MASK,                "EOF_mask");
    2928        pabloS2CCode.put(PabloSBuiltin.NULL_BUILTIN,            "null_builtin_error");
    3029
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltin2CPP.java

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

    r3373 r3375  
    11package toolchain.pabloS.lang;
    22
     3import static toolchain.pabloB.lang.idisa.IDISABuiltin.BITBLOCK_ANY;
    34import static toolchain.pabloB.lang.idisa.IDISABuiltin.SIMD_CONSTANT;
     5import static toolchain.pabloB.lang.types.PrimitiveType.BITBLOCK_SIZE;
    46
    57import java.util.ArrayList;
     
    2527
    2628public enum PabloSBuiltinTranslator {
    27    
    28     ASSERT_ZERO_TRANSLATION {
    29         public void  translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode node, Context context) {
    30            
    31         }
    32     },
    3329   
    3430        CARRY_TRANSLATION {     
     
    8278    },
    8379   
     80    ASSERT_ZERO_TRANSLATION {
     81        public ASTNode translate(PabloSBuiltin translatedBuiltin, pabloS.ast.FuncCallNode snode, Context context,  List<ASTNode> childResults) {
     82           
     83            Locator locator = toolchain.pabloB.ast.Generators.makeToken(snode.getToken());
     84           
     85            FuncCallArgListNode args = (FuncCallArgListNode) childResults.get(1);
     86            ASTNode errorStream      = args.child(0);
     87            ASTNode errorMsg         = args.child(1);
     88           
     89            String assert0CallName                  = context.getBuiltinEncoder().getName(PabloSBuiltin.ASSERT_ZERO);
     90
     91
     92            ASTNode assert0Call                     = toolchain.pabloB.ast.Generators.makeFuncCallNode(locator,
     93                    assert0CallName,
     94                    errorStream,             
     95                    errorMsg);
     96
     97            BlockStmtNode blockStmt                 = toolchain.pabloB.ast.Generators.makeBlockStmtNode(locator, assert0Call);
     98            IfStmtNode replacement                  = toolchain.pabloB.ast.Generators.makeIfStmtNode(locator,
     99                    errorStream.deepCopy(),
     100                    blockStmt);
     101
     102            surroundConditionWithBitBlockAny(replacement, toolchain.pabloB.ast.Accessors.condition(replacement));
     103
     104            return replacement;
     105           
     106        }
     107    },
     108   
    84109    ATEOF_TRANSLATION {
    85         public void translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Counter counter, Context context) {
     110        public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> childResults) {
     111           
     112            Locator locator = toolchain.pabloB.ast.Generators.makeToken(snode.getToken());
     113           
     114            FuncCallArgListNode args = (FuncCallArgListNode) childResults.get(1);
     115            ASTNode arg0 = args.child(0);
     116           
    86117            if(context.isFinalBlockMode()) {
    87                 pabloS.ast.ASTNode arg = Accessors.argument(snode, 0);
    88                 pabloS.ast.ASTNode replacement = Generators.makeSIMDAndCEOFMaskFuncCall(arg, context.getBuiltinEncoder());
    89                 snode.updateSelf(replacement);
    90             }
    91             else {             
    92                 pabloS.inputHandler.Locator locator = snode;
    93                 pabloS.ast.ASTNode maskCall = Generators.makeMaskFuncCall(locator, 1, 0);
    94                 snode.updateSelf(maskCall);         
     118                return toolchain.pabloB.ast.Generators.makeSIMDAndCEOFMaskFuncCall(locator, arg0);
     119
     120            } else {             
     121                FieldWidthNode fieldWidth = toolchain.pabloB.ast.Generators.makeIdisaFieldWidthNode(locator, 1);
     122                ASTNode value = toolchain.pabloB.ast.Generators.makeIntegerConstantNode(locator, 0);
     123               
     124                return toolchain.pabloB.ast.Generators.makeIdisaFuncCallNode(locator, SIMD_CONSTANT, fieldWidth, value);       
    95125            }
    96126        }
     
    98128
    99129    INFILE_TRANSLATION {
    100         public void translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Counter counter, Context context) {
    101             if(context.isFinalBlockMode()) {                   
    102                 pabloS.ast.ASTNode arg = Accessors.argument(snode, 0);
    103                 pabloS.ast.ASTNode replacement = Generators.makeSIMDAndEOFMaskFuncCall(arg, context.getBuiltinEncoder());
    104                 snode.updateSelf(replacement);
     130        public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> childResults) {
     131           
     132            Locator locator = toolchain.pabloB.ast.Generators.makeToken(snode.getToken());
     133           
     134            FuncCallArgListNode args = (FuncCallArgListNode) childResults.get(1);
     135            ASTNode arg0 = args.child(0);
     136           
     137            if(context.isFinalBlockMode()) {
     138                return toolchain.pabloB.ast.Generators.makeSIMDAndEOFMaskFuncCall(locator, arg0);
    105139            } else {
    106                 snode.updateSelf(Accessors.argument(snode,0));
     140                return arg0;
    107141            }
    108         }       
     142        }
    109143    },
    110144
    111145    MASK_TRANSLATION {
    112         public void translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Counter counter, Context context) {
    113             pabloS.inputHandler.Locator locator = snode;
    114             pabloS.ast.ASTNode maskCall = Generators.makeMaskFuncCall(locator, 1, 0);
    115             snode.updateSelf(maskCall);     
     146        public ASTNode translate(PabloSBuiltin translatedBuiltin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> childResults) {
     147           
     148            Locator locator = toolchain.pabloB.ast.Generators.makeToken(snode.getToken());
     149
     150            FuncCallArgListNode args = (FuncCallArgListNode) childResults.get(1);
     151            IntegerConstantNode n = (IntegerConstantNode)args.child(0);
     152            ASTNode fieldWidth  = toolchain.pabloB.ast.Generators.makeIdisaFieldWidthNode(locator, toolchain.pabloB.ast.Accessors.intValue(n));
     153            ASTNode value       = args.child(1);
     154           
     155            return toolchain.pabloB.ast.Generators.makeIdisaFuncCallNode(locator, SIMD_CONSTANT, (FieldWidthNode) fieldWidth, value);
    116156        }
    117157    };
    118     
     158   
    119159    private static void scanToTranslate(PabloSBuiltin translatedBuiltin, pabloS.ast.FuncCallNode snode, Counter counter, Context context, pabloS.ast.ASTNode returnValue) {
    120160        pabloS.ast.ASTNode argument = Accessors.argument(snode, 1);
     
    151191        }
    152192
     193        public ASTNode translate(PabloSBuiltin translatedBuiltin, pabloS.ast.FuncCallNode node, Context context, List<ASTNode> childResults) {
     194            assert false : "'pablo_blk_' PabloSBuiltin translate not implemented for PabloSBuitin: " + this.name();
     195            return null;
     196        }
     197       
    153198        // helper methods
    154        
    155     private ASTNode makeAllZeroesCall(pabloS.ast.FuncCallNode snode) {
    156        
    157         String idisaPackage = SIMD_CONSTANT.packageName();
    158         String idisaOperation = SIMD_CONSTANT.baseName();
    159 
    160         int fw            = Integer.valueOf(toolchain.pabloS.ast.Accessors.argument(snode, 0).getToken().getLexeme());
    161         int value         = Integer.valueOf(toolchain.pabloS.ast.Accessors.argument(snode, 1).getToken().getLexeme());
    162        
    163         Locator locator = toolchain.pabloB.ast.Generators.makeToken(snode.getToken());
    164         IntegerConstantNode valueNode = toolchain.pabloB.ast.Generators.makeIntegerConstantNode(locator, value);
    165        
    166         ASTNode replacement = toolchain.pabloB.ast.Generators.makeIdisaFuncCallNode(locator, idisaPackage, idisaOperation, fw, valueNode);
    167         return replacement;
    168     }
     199    private static void surroundConditionWithBitBlockAny(ASTNode node, ASTNode condition) {
     200        Locator locator = node;
     201       
     202        ASTNode replacement = toolchain.pabloB.ast.Generators.makeIdisaFuncCallNode(locator, BITBLOCK_ANY, BITBLOCK_SIZE, toolchain.pabloB.ast.Generators.arguments(condition.deepCopy()));
     203       
     204        node.replaceChild(condition, replacement);
     205    }   
    169206       
    170207    private static void replaceCallWithPabloBlkCall (
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/pabloS2PabloB/CarryIntroXFormer.java

    r3370 r3375  
    44import pabloS.ast.*;
    55import pabloS.inputHandler.Locator;
     6import toolchain.pabloB.lang.PabloBBuiltin;
    67import toolchain.pabloS.ast.*;
    78import toolchain.pabloS.lang.*;
     
    141142                ParameterNode lastParameter = (ParameterNode)parameterList.lastChild();
    142143
    143                 final String EOF_Mask = context.getBuiltinEncoder().getName(PabloSBuiltin.EOF_MASK);
     144                final String EOF_Mask = PabloBBuiltin.EOF_MASK.pabloBName(); //context.getBuiltinEncoder().getName(PabloSBuiltin.EOF_MASK);
    144145
    145146                if(Accessors.name(lastParameter).equals(EOF_Mask)) {
     
    198199                public void visitLeave(FuncCallNode node) {
    199200                        if(BuiltinCallUtil.isCarryNone(node)) {
    200                             if(!BuiltinCallUtil.isAssertZero(node)) {
     201                            if(!BuiltinCallUtil.isAssertZero(node) && !BuiltinCallUtil.isMask(node) && !BuiltinCallUtil.isInFile(node) && !BuiltinCallUtil.isAtEOF(node)) {
    201202                           
    202203                                PabloSBuiltin builtin = BuiltinCallUtil.builtin(node);
    203 
    204 
    205 
    206204                                Counter counter = selectCounter(builtin, carryCounter, advanceNCounter);
    207205                                PabloSBuiltinTranslator translator = builtin.getTranslator();
    208 
    209 
    210 
    211206                                translator.translate(builtin, node, counter, context);
     207
    212208                            }
    213209                        }       
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/pabloS2PabloB/PabloS2PabloBXFormer.java

    r3370 r3375  
    2626import toolchain.pabloS.lang.PabloSBuiltin;
    2727import toolchain.pabloS.lang.PabloSBuiltinEncoder;
     28import toolchain.pabloS.lang.PabloSBuiltinTranslator;
    2829import toolchain.pabloS.lang.carrySet.CarrySetEncoder;
     30
    2931
    3032import toolchain.pabloS.transformer.visitors.infoSet.StreamFunctionInfoSet;
     
    6567        // Map<pabloB.ast.ASTNode, pabloS.ast.ASTNode> B2SMap;
    6668
    67         pabloB.ast.ASTNode ASTree               = decoratedASTreeS.accept(new ASTBuilder());
    68         pabloB.ast.ASTNode finalASTree      = finalDecoratedASTTreeS.accept(new ASTBuilder());
     69        pabloB.ast.ASTNode ASTree               = decoratedASTreeS.accept(new ASTBuilder(false));        // TODO - KH: context object
     70        pabloB.ast.ASTNode finalASTree      = finalDecoratedASTTreeS.accept(new ASTBuilder(true));
    6971
    7072        Map<String, pabloB.ast.FuncDefNode> map              = makeFuncDefMap(ASTree);
     
    196198    private static class ASTBuilder extends pabloS.ast.ASTVisitor.Default<pabloB.ast.ASTNode> {
    197199
     200        private Context context;
     201       
     202        ASTBuilder(boolean finalBlockMode) {
     203            context = new Context(builtinEncoder, carrySetEncoder, true, finalBlockMode, 0);
     204        }
     205       
    198206        // General case.
    199207        @Override
     
    243251        }
    244252
    245         public pabloB.ast.ASTNode visitLeave(pabloS.ast.FuncCallNode snode, List<pabloB.ast.ASTNode> childResults) {
    246 
    247             if (BuiltinCallUtil.isAssertZero(snode)) {
     253        public ASTNode visitLeave(pabloS.ast.FuncCallNode snode, List<ASTNode> childResults) {
     254
     255            if (BuiltinCallUtil.isCarryNone(snode)) { //
    248256               
    249                 Locator locator = Generators.makeToken(snode.getToken());
    250                 return makeAssert0Call(locator, childResults);
    251             }
    252            
    253             if(BuiltinCallUtil.isMask(snode)) {
    254                 Locator locator = Generators.makeToken(snode.getToken());
    255                 return makeAllZeroesCall(snode, locator);
    256 
     257                PabloSBuiltin builtin = BuiltinCallUtil.builtin(snode);
     258                PabloSBuiltinTranslator translator = builtin.getTranslator();
     259                               
     260                return translator.translate(builtin, snode, context, childResults);
     261               
    257262            } else {
    258263               
    259                 pabloB.ast.ASTNode replacment  = new pabloB.ast.FuncCallNode(Generators.makeToken(snode.getToken()));
     264                ASTNode replacment  = new FuncCallNode(Generators.makeToken(snode.getToken()));
    260265                appendChildResults(replacment, childResults);
    261266               
     
    264269        }
    265270
    266         private ASTNode makeAllZeroesCall(pabloS.ast.FuncCallNode snode, Locator locator) {
    267            
    268             String idisaPackage = SIMD_CONSTANT.packageName();
    269             String idisaOperation = SIMD_CONSTANT.baseName();
    270 
    271             int fw            = Integer.valueOf(toolchain.pabloS.ast.Accessors.argument(snode, 0).getToken().getLexeme());
    272             int value         = Integer.valueOf(toolchain.pabloS.ast.Accessors.argument(snode, 1).getToken().getLexeme());
    273             IntegerConstantNode valueNode = Generators.makeIntegerConstantNode(locator, value);
    274            
    275             ASTNode replacement = Generators.makeIdisaFuncCallNode(locator, idisaPackage, idisaOperation, fw, valueNode);
    276             return replacement;
    277         }
    278 
    279         private pabloB.ast.ASTNode makeAssert0Call(
    280                 Locator locator,
    281                 List<pabloB.ast.ASTNode> childResults) {
    282            
    283             String assert0CallName                  = builtinEncoder.getName(PabloSBuiltin.ASSERT_ZERO);
    284             pabloB.ast.ASTNode errorStream          = childResults.get(1).child(0).deepCopy();
    285             pabloB.ast.ASTNode errorMsg             = childResults.get(1).child(1).deepCopy();
    286            
    287             pabloB.ast.ASTNode assert0Call          = Generators.makeFuncCallNode(locator,
    288                                                                                     assert0CallName,
    289                                                                                     errorStream,             
    290                                                                                     errorMsg);
    291          
    292             BlockStmtNode blockStmt                 = Generators.makeBlockStmtNode(locator, assert0Call);
    293             IfStmtNode replacement                  = Generators.makeIfStmtNode(locator,
    294                                                               errorStream.deepCopy(),
    295                                                               blockStmt);
    296            
    297             surroundConditionWithBitBlockAny(replacement, Accessors.condition(replacement));
    298 
    299             return replacement;
    300         }
     271//        private ASTNode makeIdisaConstant(Locator locator, int fw, int value) {
     272//           
     273//            IntegerConstantNode valueNode = Generators.makeIntegerConstantNode(locator, value);
     274//            FieldWidthNode fieldWidth = Generators.makeIdisaFieldWidthNode(locator, fw);
     275//           
     276//            ASTNode replacement = Generators.makeIdisaFuncCallNode(locator, SIMD_CONSTANT, fieldWidth, valueNode);
     277//            return replacement;
     278//        }
     279
     280
    301281       
    302282        /*       
    303         private pabloB.ast.ASTNode makeSIMDConstantCall(
     283        private ASTNode makeSIMDConstantCall(
    304284                String assert0CallName                  = builtinEncoder.getName(PabloSBuiltin.ASSERT_ZERO);
    305                 pabloB.ast.ASTNode errorStream          = childResults.get(1).deepCopy();
    306                 pabloB.ast.ASTNode errorMsg             = childResults.get(2).deepCopy();
    307 
    308                 pabloB.ast.ASTNode assert0Call          = Generators.makeFuncCallNode(locator,
     285                ASTNode errorStream          = childResults.get(1).deepCopy();
     286                ASTNode errorMsg             = childResults.get(2).deepCopy();
     287
     288                ASTNode assert0Call          = Generators.makeFuncCallNode(locator,
    309289                        assert0CallName,
    310290                        errorStream,             
     
    312292
    313293                BlockStmtNode blockStmt                 = Generators.makeBlockStmtNode(locator, assert0Call);
    314                 pabloB.ast.ASTNode replacement          = Generators.makeIfStmtNode(locator,
     294                ASTNode replacement          = Generators.makeIfStmtNode(locator,
    315295                        errorStream.deepCopy(),
    316296                        blockStmt);
     
    321301       
    322302
    323         public pabloB.ast.ASTNode visitLeave(pabloS.ast.IntegerConstantNode snode, List<pabloB.ast.ASTNode> childResults) {
    324             pabloB.ast.ASTNode replacement = new pabloB.ast.IntegerConstantNode(Generators.makeToken(snode.getToken()));
     303        public ASTNode visitLeave(pabloS.ast.IntegerConstantNode snode, List<ASTNode> childResults) {
     304            ASTNode replacement = new IntegerConstantNode(Generators.makeToken(snode.getToken()));
    325305            int value = new Integer(replacement.getToken().getLexeme());
    326             ((pabloB.ast.IntegerConstantNode)replacement).setValue(value); // set integer constant value
     306            ((IntegerConstantNode)replacement).setValue(value); // set integer constant value
    327307            appendChildResults(replacement, childResults);
    328308            return replacement;
     
    330310
    331311
    332         public pabloB.ast.ASTNode visitLeave(pabloS.ast.BinaryOperatorNode snode, List<pabloB.ast.ASTNode> childResults) {
     312        public ASTNode visitLeave(pabloS.ast.BinaryOperatorNode snode, List<ASTNode> childResults) {
    333313
    334314            pabloS.tokens.Token tokenS = snode.getToken();
     
    336316            pabloS.ast.ASTNode rhsS = toolchain.pabloS.ast.Accessors.rhs(snode);
    337317           
    338             pabloB.ast.ASTNode replacement = null;
     318            ASTNode replacement = null;
    339319
    340320            if(tokenS.isLextant(pabloS.lexicalAnalyzer.Lextant.AND, pabloS.lexicalAnalyzer.Lextant.OR, pabloS.lexicalAnalyzer.Lextant.XOR)) {
     
    371351        }       
    372352
    373         public pabloB.ast.ASTNode visitLeave(pabloS.ast.UnaryOperatorNode snode, List<pabloB.ast.ASTNode> childResults) {
     353        public ASTNode visitLeave(pabloS.ast.UnaryOperatorNode snode, List<ASTNode> childResults) {
    374354
    375355            pabloS.tokens.Token token = snode.getToken();
     
    379359            if(token.isLextant(pabloS.lexicalAnalyzer.Lextant.NOT)) {
    380360                pabloB.inputHandler.TextLocation locator = Generators.makeTextLocation(token.getLocation());
    381                 pabloB.ast.ASTNode operand = childResults.get(0);
     361                ASTNode operand = childResults.get(0);
    382362                replacement = Generators.makeIdisaFuncCallNode(locator, SIMD_NOT, BITBLOCK_SIZE, Generators.arguments(operand));
    383363            } else {
     
    388368        }
    389369
    390         public pabloB.ast.ASTNode visitLeave(pabloS.ast.IfStmtNode snode, List<pabloB.ast.ASTNode> childResults) {
     370        public ASTNode visitLeave(pabloS.ast.IfStmtNode snode, List<ASTNode> childResults) {
    391371
    392372            pabloB.tokens.Token pabloBToken = Generators.makeToken(snode.getToken());
    393             pabloB.ast.IfStmtNode replacement = new pabloB.ast.IfStmtNode(pabloBToken);
     373            IfStmtNode replacement = new IfStmtNode(pabloBToken);
    394374            appendChildResults(replacement, childResults);
    395375           
     
    398378        }
    399379       
    400         public pabloB.ast.ASTNode visitLeave(pabloS.ast.WhileStmtNode snode, List<pabloB.ast.ASTNode> childResults) {
     380        public ASTNode visitLeave(pabloS.ast.WhileStmtNode snode, List<ASTNode> childResults) {
    401381
    402382            pabloB.tokens.Token pabloBToken = Generators.makeToken(snode.getToken());
    403             pabloB.ast.WhileStmtNode replacement = new pabloB.ast.WhileStmtNode(pabloBToken);
     383            WhileStmtNode replacement = new WhileStmtNode(pabloBToken);
    404384            appendChildResults(replacement, childResults);
    405385           
     
    411391    }   
    412392   
    413     private static void surroundConditionWithBitBlockAny(ASTNode node, pabloB.ast.ASTNode condition) {
     393    private static void surroundConditionWithBitBlockAny(ASTNode node, ASTNode condition) {
    414394        Locator locator = node;
    415395       
    416         String idisaPackage = BITBLOCK_ANY.packageName();
    417         String idisaOperation = BITBLOCK_ANY.baseName();
    418        
    419         int fw = BITBLOCK_SIZE;
    420        
    421         ASTNode replacement = Generators.makeIdisaFuncCallNode(locator, idisaPackage, idisaOperation, fw, Generators.arguments(condition.deepCopy()));
     396       
     397        ASTNode replacement = Generators.makeIdisaFuncCallNode(locator, BITBLOCK_ANY, BITBLOCK_SIZE, Generators.arguments(condition.deepCopy()));
    422398       
    423399        node.replaceChild(condition, replacement);
Note: See TracChangeset for help on using the changeset viewer.