Ignore:
Timestamp:
Jun 21, 2013, 2:12:40 PM (6 years ago)
Author:
ksherdy
Message:

Harmonized builtin names for both CarrySet? and PabloS. Initial refactoring to centralize CarrySet? function call generation.

Location:
proto/pabloj/trunk/src
Files:
17 edited
7 moved

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/application/generators/ApplicationGenerator.java

    r3277 r3345  
    5757               
    5858                // Transformation configurations to support multiple backends
    59                 toolchain.pabloS.lang.BuiltinEncoder pabloSbuiltinsEncoder  = null;
     59                toolchain.pabloS.lang.PabloSBuiltinEncoder pabloSbuiltinsEncoder  = null;
    6060                toolchain.pabloB.lang.BuiltinEncoder pabloBBuiltinsEncoder  = null;
    6161                AbstractUnparser unparser                                                                       = null;
     
    6464                               
    6565                if(applicationConfiguration.getTarget() == Target.C_LANG) {
    66             pabloSbuiltinsEncoder       = new toolchain.pabloS.lang.PabloSBuiltins2C();
     66            pabloSbuiltinsEncoder       = new toolchain.pabloS.lang.PabloSBuiltin2C();
    6767            pabloBBuiltinsEncoder       = new toolchain.pabloB.lang.PabloBBuiltins2C();
    68             carrySetEncoder             = new toolchain.pabloS.lang.carrySet.CarrySetBuiltins2C();
     68            carrySetEncoder             = new toolchain.pabloS.lang.carrySet.CarrySetBuiltin2C();
    6969                        unparser                        = new Unparser(new IDISABuiltin2C());                   
    7070                } else if(applicationConfiguration.getTarget() == Target.CPP_LANG) {
    71                         pabloSbuiltinsEncoder   = new toolchain.pabloS.lang.PabloSBuiltins2CPP();
     71                        pabloSbuiltinsEncoder   = new toolchain.pabloS.lang.PabloSBuiltin2CPP();
    7272                        pabloBBuiltinsEncoder   = new toolchain.pabloB.lang.PabloBBuiltins2CPP();
    73                         carrySetEncoder                 = new toolchain.pabloS.lang.carrySet.CarrySetBuiltins2CPP();
     73                        carrySetEncoder                 = new toolchain.pabloS.lang.carrySet.CarrySetBuiltin2CPP();
    7474                        unparser                                = new Unparser(new IDISABuiltin2CPP());
    7575                } /*else if(applicationConfiguration.targetLang.contentEquals(Configuration.LLVM)) {  // default C++
  • proto/pabloj/trunk/src/pabloS/ast/BlockStmtNode.java

    r3295 r3345  
    1010import java.util.List;
    1111
     12import toolchain.pabloS.semanticAnalyzer.SymbolTable;
    1213
    1314
    14 public class BlockStmtNode extends ASTNode  {
     15public class BlockStmtNode extends ASTNode implements HasSymbolTableNodeType {
     16        private SymbolTable symbolTable = null;
    1517
    1618
     
    2022        public BlockStmtNode(BlockStmtNode node) {
    2123                super(node);
     24                this.symbolTable = node.symbolTable;
    2225
    2326        }
     
    3841        // attribute accessors
    3942
     43        public SymbolTable getSymbolTable() {
     44                return symbolTable;
     45        }
     46        public void setSymbolTable(SymbolTable _value_) {
     47                symbolTable = _value_;
     48        }
     49       
    4050
    4151       
     
    4959                        result += ", ";
    5060                }
     61                result += "symbolTable = " + symbolTable + ", ";
    5162
    5263                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloS/parser/Parser.java

    r3330 r3345  
    489489                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    490490                {
    491                         ASTNode child = parseCompoundIdentifier();
     491                        ASTNode child = parseIdentifier();
    492492                        result.appendChild(child);
    493493                        allChildren.add(child);
  • proto/pabloj/trunk/src/test/pabloS/PabloSTestHarness.java

    r3325 r3345  
    2222import test.helpers.FileUtil;
    2323import test.helpers.AssertNodePairComparator;
    24 import toolchain.pabloS.lang.BuiltinEncoder;
    25 import toolchain.pabloS.lang.PabloSBuiltins2CPP;
    26 import toolchain.pabloS.lang.carrySet.CarrySetBuiltins2CPP;
     24import toolchain.pabloS.lang.PabloSBuiltinEncoder;
     25import toolchain.pabloS.lang.PabloSBuiltin2CPP;
     26import toolchain.pabloS.lang.carrySet.CarrySetBuiltin2CPP;
    2727import toolchain.pabloS.lang.carrySet.CarrySetEncoder;
    2828import toolchain.pabloS.transformer.visitors.CombineAdvances;
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Accessors.java

    r3335 r3345  
    328328        String name = new String();
    329329        if(node instanceof IdentifierNode) {
    330             name = Accessors.name(node);
     330            name = Accessors.name((IdentifierNode)node);
    331331        }
    332332        else if (node instanceof CompoundIdentifierNode) {
    333333            ASTNode pckage = node.child(0);
    334334            ASTNode member = node.child(1);
    335             name = Accessors.name(pckage);
     335            name = Accessors.name((IdentifierNode)pckage);
    336336            name += ".";
    337             name += Accessors.name(member);
     337            name += Accessors.name((IdentifierNode)member);
    338338        }
    339339        else {  // TS: added
     
    352352        public static String structName(StructDeclNode node) {
    353353        String name = new String();
    354         name = Accessors.name(node.child(0));
     354        name = Accessors.name((IdentifierNode)node.child(0));
    355355        return name;
    356356        }
     
    372372       
    373373        public static String structMemberName(StructMemberNode node) {
    374         return Accessors.name(node.child(1));
     374        return Accessors.name((IdentifierNode)node.child(1));
    375375        }       
    376376
     
    391391        // 2^k stream type
    392392        ////////////////////////////////////////////////////////////////////////////
    393         public static String streamTypeName(StreamTypeNode node) {
    394                 return Accessors.name(node);
    395         }       
    396393
    397394        ////////////////////////////////////////////////////////////////////////////
     
    431428        }
    432429        public static String pckageName(CompoundIdentifierNode compound) {
    433                 ASTNode pckageNode = pckageNode(compound);
     430            IdentifierNode pckageNode = pckageNode(compound);
    434431                return name(pckageNode);
    435432        }
    436         public static ASTNode pckageNode(CompoundIdentifierNode compound) {
    437                 return compound.child(0);
     433        public static IdentifierNode pckageNode(CompoundIdentifierNode compound) {
     434                return (IdentifierNode)compound.child(0);
    438435        }
    439436        public static String funcName(CompoundIdentifierNode compound) {
    440                 ASTNode funcNameNode = funcNameNode(compound);
     437            IdentifierNode funcNameNode = funcNameNode(compound);
    441438                return name(funcNameNode);
    442439        }
    443         public static ASTNode funcNameNode(CompoundIdentifierNode compound) {
    444                 return compound.child(1);
     440        public static IdentifierNode funcNameNode(CompoundIdentifierNode compound) {
     441                return (IdentifierNode)compound.child(1);
    445442        }
    446443        public static String name(CompoundIdentifierNode compound) {
     
    451448        // IdentifierNode
    452449        ////////////////////////////////////////////////////////////////////////////
    453         public static String name(ASTNode node) {
    454                 assert node instanceof IdentifierNode;
    455                 return node.getToken().getLexeme();
     450        public static String name(IdentifierNode node) {
     451            return node.getToken().getLexeme();
    456452        }
    457453       
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Generators.java

    r3330 r3345  
    1717import toolchain.pabloB.lang.idisa.*;
    1818import toolchain.pabloS.lang.*;
     19import toolchain.pabloS.lang.carrySet.CarrySetBuiltin;
     20import toolchain.pabloS.transformer.visitors.carry.Context;
    1921
    2022public class Generators {
     
    4345            localVarDecl.appendChild(type);
    4446            localVarDecl.appendChild(lhs);
    45            
    46            
    47            
    4847            return localVarDecl;
    4948        }
     
    6362        }
    6463       
    65         // Make function call variants 
     64    ///////////////////////////////////////////////////////////////////
     65    // Function call variants
    6666        public static FuncCallNode makeFuncCallNode(Locator locator, String identifier) {
    6767                IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier);     
     
    9999               
    100100        private static void addFuncCallArgs(FuncCallNode node, ASTNode ... args) {
    101                 if(args.length > 0) {
    102                         for(ASTNode child: args) {
    103                                 Accessors.argsListNode(node).appendChild(child);
    104                         }
    105                         Accessors.argsListNode(node).setToken(args[0].getToken());
    106                 }       
    107         }               
     101            for(ASTNode child: args) {
     102                Accessors.argsListNode(node).appendChild(child);
     103            }
     104            Accessors.argsListNode(node).setToken(args[0].getToken());
     105        }
     106       
    108107        public static CompoundIdentifierNode makeCompoundIdentifierNode(Locator locator, String pckage, String name) {
    109108                return makeCompoundIdentifierNode(locator, new String [] {pckage, name});
     
    225224                return ifStmtNode;
    226225        }
    227        
     226
     227    ///////////////////////////////////////////////////////////////////
     228    // Mask calls
    228229        public static FuncCallNode makeMaskFuncCall(Locator locator, int fieldWidth, int value) {
    229230                IntegerConstantNode zeroConstantNode =  Generators.makeIntegerConstantNode(locator, value);
     
    236237        }
    237238       
    238         public static FuncCallNode makeSIMDAndEOFMaskFuncCall(ASTNode node, BuiltinEncoder encoder) {
     239        ///////////////////////////////////////////////////////////////////
     240        // SIMD EOF_mask calls
     241        public static FuncCallNode makeSIMDAndEOFMaskFuncCall(ASTNode node, PabloSBuiltinEncoder encoder) {
    239242                Locator location = (Locator)node;
    240                 ASTNode eofMask = makeIdentifierNode(location, encoder.getCode(PabloSBuiltin.EOF_MASK));
     243                ASTNode eofMask = makeIdentifierNode(location, encoder.getName(PabloSBuiltin.EOF_MASK));
    241244                return Generators.makeFuncCallNode(location, IDISASIMDBitwiseBuiltins.AND.Name(), arguments(node, eofMask));
    242245        }               
    243         private static ASTNode[] arguments(ASTNode...astNodes) {
    244                 return astNodes;
    245         }
    246 
    247         public static FuncCallNode makeSIMDAndCEOFMaskFuncCall(ASTNode node, BuiltinEncoder builtins2Lang) {
    248                 ASTNode [] args = new ASTNode [2];
    249                 args[0] = node;
    250                 args[1] = Generators.makeIdentifierNode(node.getToken(), builtins2Lang.getCode(PabloSBuiltin.EOF_MASK));
     246
     247        public static FuncCallNode makeSIMDAndCEOFMaskFuncCall(ASTNode node, PabloSBuiltinEncoder encoder) {
     248                ASTNode [] args = arguments(node, Generators.makeIdentifierNode(node.getToken(), encoder.getName(PabloSBuiltin.EOF_MASK)));
    251249                return Generators.makeFuncCallNode(node.getToken(), IDISASIMDBitwiseBuiltins.ANDC.Name(), args);
    252250        }       
    253251
    254         public static FuncCallNode makeSIMDEOFMaskAndCNodeFuncCall(ASTNode node, BuiltinEncoder builtins2Lang) {
    255                 ASTNode [] args = new ASTNode [2];
    256                 args[0] = Generators.makeIdentifierNode(node.getToken(), builtins2Lang.getCode(PabloSBuiltin.EOF_MASK));
    257                 args[1] = node;
     252        public static FuncCallNode makeSIMDEOFMaskAndCNodeFuncCall(ASTNode node, PabloSBuiltinEncoder encoder) {
     253                ASTNode [] args = arguments(Generators.makeIdentifierNode(node.getToken(), encoder.getName(PabloSBuiltin.EOF_MASK)), node);
    258254                return Generators.makeFuncCallNode(node.getToken(), IDISASIMDBitwiseBuiltins.ANDC.Name(), args);
    259255        }               
    260256       
    261         public static FuncCallNode makeSIMDNotFuncCall(ASTNode node, BuiltinEncoder builtins2Lang) {
    262                 ASTNode [] args = new ASTNode [1];
    263                 args[0] = node;
     257        public static FuncCallNode makeSIMDNotFuncCall(ASTNode node, PabloSBuiltinEncoder encoder) {
     258                ASTNode [] args = arguments(node);
    264259                return Generators.makeFuncCallNode(node.getToken(), IDISASIMDBitwiseBuiltins.NOT.Name(), args);
    265260        }               
    266261       
    267         public static ParameterNode makeEOFMaskParameter(Locator locator, BuiltinEncoder builtins2Lang) {
     262        public static ParameterNode makeEOFMaskParameter(Locator locator, PabloSBuiltinEncoder encoder) {
    268263               
    269264                Token parameterNodeToken = Generators.makeLextantToken(locator, Lextant.STREAM);
     
    272267                Token streamTypeToken = Generators.makeLextantToken(locator, Lextant.STREAM);
    273268                StreamTypeNode streamTypeNode = new StreamTypeNode(streamTypeToken);
    274                 IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, builtins2Lang.getCode(PabloSBuiltin.EOF_MASK));
     269                IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, encoder.getName(PabloSBuiltin.EOF_MASK));
    275270               
    276271                parameterNode.appendChild(streamTypeNode);
     
    279274                return parameterNode;
    280275        }
    281        
    282         // Helpers
     276
     277    ///////////////////////////////////////////////////////////////////
     278    // Carry builtin calls
     279    public static ASTNode makeGetCallCarryForBuiltin(Locator locator, PabloSBuiltin builtin, int index, Context context) {
     280        if(builtin.isCarryN()) {
     281            return makePending64Call(locator, index, context);
     282        } else {
     283            return makeGetCarryCall(locator, index, context);
     284        }
     285    }
     286   
     287    public static ASTNode makeGetCarryCall(Locator locator, int index, Context context) {
     288        return Generators.makeFuncCallNode(
     289                locator,
     290                context.getCarrySetIdentifier(),
     291                context.getCarrySetEncoder().getName(CarrySetBuiltin.GETCARRY),
     292                Generators.makeIntegerConstantNode(locator, index));
     293    }
     294   
     295    public static ASTNode makePending64Call(Locator locator, int index, Context context) {
     296        return Generators.makeFuncCallNode(
     297                locator,
     298                context.getCarrySetIdentifier(),
     299                context.getCarrySetEncoder().getName(CarrySetBuiltin.PENDING64),
     300                Generators.makeIntegerConstantNode(locator, index));
     301    }
     302       
     303    ///////////////////////////////////////////////////////////////////
     304    // Helpers
     305        public static ASTNode[] arguments(ASTNode...astNodes) {
     306            return astNodes;
     307        }
     308       
    283309        public static String capitalize(String str) {
    284310                return str.substring(0, 1).toUpperCase() + str.substring(1);
     
    288314                return str.substring(0, 1).toLowerCase() + str.substring(1);
    289315        }
    290        
    291316
    292317}
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltin2C.java

    r3325 r3345  
    44import java.util.Map;
    55
    6 public class PabloSBuiltins2C extends BuiltinEncoder {
     6public class PabloSBuiltin2C extends PabloSBuiltinEncoder {
    77       
    88        private static Map<PabloSBuiltin, String> pabloS2CCode;
     
    3131        for(PabloSBuiltin builtin : PabloSBuiltin.values()) {
    3232                if(!pabloS2CCode.containsKey(builtin)) {
    33                                 throw new RuntimeException("PabloS builtin to C mapping not unimplemented in :" + PabloSBuiltins2C.class.getSimpleName());
     33                                throw new RuntimeException("PabloS builtin to C mapping not unimplemented in :" + PabloSBuiltin2C.class.getSimpleName());
    3434                }
    3535        }
     
    3737
    3838        @Override
    39         public String getCode(PabloSBuiltin builtin) {
     39        public String getName(PabloSBuiltin builtin) {
    4040                return pabloS2CCode.get(builtin);
    4141        }
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltin2CPP.java

    r3325 r3345  
    1515import java.util.Map;
    1616
    17 public class PabloSBuiltins2CPP extends BuiltinEncoder {
     17public class PabloSBuiltin2CPP extends PabloSBuiltinEncoder {
    1818
    1919        private static Map<PabloSBuiltin, String> pabloS2CPPCode;
     
    4242        for(PabloSBuiltin builtin : PabloSBuiltin.values()) {
    4343                if(!pabloS2CPPCode.containsKey(builtin)) {
    44                                 throw new RuntimeException("PabloS builtin to CPP mapping not unimplemented in :" + PabloSBuiltins2CPP.class.getSimpleName());
     44                                throw new RuntimeException("PabloS builtin to CPP mapping not unimplemented in :" + PabloSBuiltin2CPP.class.getSimpleName());
    4545                }
    4646        }
    4747    }
    4848   
    49         public String getCode(PabloSBuiltin builtin) {                 
     49        public String getName(PabloSBuiltin builtin) {                 
    5050                return pabloS2CPPCode.get(builtin);
    5151        }
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltinEncoder.java

    r3293 r3345  
    11package toolchain.pabloS.lang;
    22
    3 public abstract class BuiltinEncoder {
    4         public abstract String getCode(PabloSBuiltin builtin);
     3public abstract class PabloSBuiltinEncoder {
     4        public abstract String getName(PabloSBuiltin builtin);
    55}
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/carrySet/CarrySetBuiltin.java

    r3293 r3345  
    11/*
    2  * Carry set builtin function signatures.
    3  *
    4  * TODO - Migrate to 'function signature style' to support type checking.
     2 * Carry set builtin functions.
    53 *
    64 * @author Ken Herdy <ksherdy at sfu dot ca>
     
    108package toolchain.pabloS.lang.carrySet;
    119
    12 public enum CarrySetBuiltins {
     10public enum CarrySetBuiltin {
    1311        CARRYDECLARE(3),               
    1412        CARRYRANGE(2),
     
    2422        private final int argCount;
    2523               
    26         CarrySetBuiltins(int argCount ) {
     24        CarrySetBuiltin(int argCount ) {
    2725                this.argCount = argCount;
    2826        }
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/carrySet/CarrySetBuiltin2C.java

    r3306 r3345  
    55
    66
    7 public class CarrySetBuiltins2C extends CarrySetEncoder {
     7public class CarrySetBuiltin2C extends CarrySetEncoder {
    88       
    9         private static Map<CarrySetBuiltins, String> carry2CCode;
     9        private static Map<CarrySetBuiltin, String> carry2CCode;
    1010       
    1111    static {
    1212       
    13         carry2CCode = new HashMap<CarrySetBuiltins, String>();
    14         carry2CCode.put(CarrySetBuiltins.CARRYDECLARE, "CarryDeclare");             // Macros
    15         carry2CCode.put(CarrySetBuiltins.LOCALCARRYCOMBINE,"LocalCarryCombine");
    16         carry2CCode.put(CarrySetBuiltins.CARRYRANGE,"carryRange");                  // Members
    17         carry2CCode.put(CarrySetBuiltins.GETCARRY,"getCarry");
    18         carry2CCode.put(CarrySetBuiltins.SETCARRY,"setCarry");
    19         carry2CCode.put(CarrySetBuiltins.PENDING64,"getPending64");
    20         carry2CCode.put(CarrySetBuiltins.CARRYADJUST,"carryAdjust");
    21         carry2CCode.put(CarrySetBuiltins.CARRYDEQUEUEENQUEUE,"carryDequeueEnqueue");
    22         carry2CCode.put(CarrySetBuiltins.CARRYFLIP,"carryFlip");
     13        carry2CCode = new HashMap<CarrySetBuiltin, String>();
     14        carry2CCode.put(CarrySetBuiltin.CARRYDECLARE, "CarryDeclare");             // Macros
     15        carry2CCode.put(CarrySetBuiltin.LOCALCARRYCOMBINE,"LocalCarryCombine");
     16        carry2CCode.put(CarrySetBuiltin.CARRYRANGE,"carryRange");                  // Members
     17        carry2CCode.put(CarrySetBuiltin.GETCARRY,"getCarry");
     18        carry2CCode.put(CarrySetBuiltin.SETCARRY,"setCarry");
     19        carry2CCode.put(CarrySetBuiltin.PENDING64,"getPending64");
     20        carry2CCode.put(CarrySetBuiltin.CARRYADJUST,"carryAdjust");
     21        carry2CCode.put(CarrySetBuiltin.CARRYDEQUEUEENQUEUE,"carryDequeueEnqueue");
     22        carry2CCode.put(CarrySetBuiltin.CARRYFLIP,"carryFlip");
    2323       
    24         for(CarrySetBuiltins op : CarrySetBuiltins.values()) {
     24        for(CarrySetBuiltin op : CarrySetBuiltin.values()) {
    2525                if(!carry2CCode.containsKey(op)) {
    26                         throw new RuntimeException("CarrySet to C code mapping unimplemented :" + CarrySetBuiltins2CPP.class.getSimpleName());
     26                        throw new RuntimeException("CarrySet to C code mapping unimplemented :" + CarrySetBuiltin2CPP.class.getSimpleName());
    2727                }
    2828        }
    2929    }
    3030
    31         public String getCode(CarrySetBuiltins op) {
     31        public String getName(CarrySetBuiltin op) {
    3232                return carry2CCode.get(op);
    3333        }
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/carrySet/CarrySetBuiltin2CPP.java

    r3306 r3345  
    1111
    1212
    13 public class CarrySetBuiltins2CPP extends CarrySetEncoder {
     13public class CarrySetBuiltin2CPP extends CarrySetEncoder {
    1414       
    15         private static Map<CarrySetBuiltins, String> carry2CPPCode;
     15        private static Map<CarrySetBuiltin, String> carry2CPPCode;
    1616       
    1717    static {
    1818       
    19         carry2CPPCode = new HashMap<CarrySetBuiltins, String>();
    20         carry2CPPCode.put(CarrySetBuiltins.CARRYDECLARE, "CarryDeclare");              // macros
    21         carry2CPPCode.put(CarrySetBuiltins.LOCALCARRYCOMBINE,"LocalCarryCombine");     
    22         carry2CPPCode.put(CarrySetBuiltins.CARRYRANGE,"carryRange");                   // members
    23         carry2CPPCode.put(CarrySetBuiltins.GETCARRY,"getCarry");
    24         carry2CPPCode.put(CarrySetBuiltins.SETCARRY,"setCarry");
    25         carry2CPPCode.put(CarrySetBuiltins.PENDING64,"getPending64");
    26         carry2CPPCode.put(CarrySetBuiltins.CARRYADJUST,"carryAdjust");
    27         carry2CPPCode.put(CarrySetBuiltins.CARRYDEQUEUEENQUEUE,"carryDequeueEnqueue");
    28         carry2CPPCode.put(CarrySetBuiltins.CARRYFLIP,"carryFlip");
     19        carry2CPPCode = new HashMap<CarrySetBuiltin, String>();
     20        carry2CPPCode.put(CarrySetBuiltin.CARRYDECLARE, "CarryDeclare");              // macros
     21        carry2CPPCode.put(CarrySetBuiltin.LOCALCARRYCOMBINE,"LocalCarryCombine");       
     22        carry2CPPCode.put(CarrySetBuiltin.CARRYRANGE,"carryRange");                   // members
     23        carry2CPPCode.put(CarrySetBuiltin.GETCARRY,"getCarry");
     24        carry2CPPCode.put(CarrySetBuiltin.SETCARRY,"setCarry");
     25        carry2CPPCode.put(CarrySetBuiltin.PENDING64,"getPending64");
     26        carry2CPPCode.put(CarrySetBuiltin.CARRYADJUST,"carryAdjust");
     27        carry2CPPCode.put(CarrySetBuiltin.CARRYDEQUEUEENQUEUE,"carryDequeueEnqueue");
     28        carry2CPPCode.put(CarrySetBuiltin.CARRYFLIP,"carryFlip");
    2929       
    30         for(CarrySetBuiltins op : CarrySetBuiltins.values()) {
     30        for(CarrySetBuiltin op : CarrySetBuiltin.values()) {
    3131                if(!carry2CPPCode.containsKey(op)) {
    32                                 throw new RuntimeException("CarrySet to CPP code mapping unimplemented :" + CarrySetBuiltins2CPP.class.getSimpleName());
     32                                throw new RuntimeException("CarrySet to CPP code mapping unimplemented :" + CarrySetBuiltin2CPP.class.getSimpleName());
    3333                }
    3434        }
    3535    }
    3636   
    37         public String getCode(CarrySetBuiltins op) {                   
     37        public String getName(CarrySetBuiltin op) {                     
    3838                return carry2CPPCode.get(op);
    3939        }
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/carrySet/CarrySetEncoder.java

    r3343 r3345  
    1010public abstract class CarrySetEncoder {
    1111       
    12         public abstract String getCode(CarrySetBuiltins op);
     12        public abstract String getName(CarrySetBuiltin op);
    1313       
    1414        public static final String CARRYSET_NAME_PREFIX         = "carry_set_";
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/SemanticAnalyzer.java

    r3330 r3345  
    11package toolchain.pabloS.semanticAnalyzer;
    22import java.util.List;
     3
     4
    35
    46import pabloS.ast.*;
     
    1113import toolchain.pabloS.lang.signatures.*;
    1214import toolchain.pabloS.lang.type.*;
     15// import toolchain.util.Labeller;
    1316
    1417public class SemanticAnalyzer {
    15 
    16         public class SemanticAnalysisVisitor extends VoidVisitor.Default {
     18   
     19    //////////////////////////////////////////////////////////////
     20    // static interface
     21    public static ASTNode analyze(ASTNode ASTree) {
     22        SemanticAnalysisVisitor analyzer = new SemanticAnalysisVisitor();
     23        ASTree.accept(analyzer);
     24        return ASTree;
     25    }
     26
     27    static private class SemanticAnalysisVisitor extends VoidVisitor.Default {
    1728
    1829                @Override
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/Transformer.java

    r3338 r3345  
    1010import toolchain.pabloS.lang.*;
    1111import toolchain.pabloS.lang.carrySet.CarrySetEncoder;
     12import toolchain.pabloS.semanticAnalyzer.SemanticAnalyzer;
    1213import toolchain.pabloS.transformer.visitors.*;
    1314import toolchain.pabloS.transformer.visitors.carry.*;
     
    1920        //private SymbolTable symbolTable;
    2021       
    21         private BuiltinEncoder builtinEncoder;
     22        private PabloSBuiltinEncoder builtinEncoder;
    2223        private CarrySetEncoder carrySet2Lang;
    2324        private boolean finalBlockMode;
     
    4041       
    4142        private void initDefaults() {
    42                 this.setBuiltins2Lang(new PabloSBuiltins2CPP());
    43                 this.setCarrySet2Lang(new toolchain.pabloS.lang.carrySet.CarrySetBuiltins2CPP());
     43                this.setBuiltins2Lang(new PabloSBuiltin2CPP());
     44                this.setCarrySet2Lang(new toolchain.pabloS.lang.carrySet.CarrySetBuiltin2CPP());
    4445                this.setFinalBlockMode(false);
    4546        }
     
    5051               
    5152            pabloS.ast.ASTNode decoratedTree = ASTTree.deepCopy();
    52                
     53           
     54
     55           
    5356                decoratedTree = ExpandAugmentedAssignments.apply(decoratedTree);
    5457                decoratedTree = SurroundAssert0sWithIfs.apply(decoratedTree, getBuiltinEncoder());             
    5558                decoratedTree = CombineAdvances.apply(decoratedTree);
     59               
     60             
    5661               
    5762                decoratedTree = CarryIntroXFormer.apply(decoratedTree, getBuiltinEncoder(), getCarrySet2Lang(), finalBlockMode);
     
    6065                decoratedTree = ConvertBitwiseBooleanToIDISACalls.apply(decoratedTree);
    6166                //decoratedTree = InitializeStreamDefaults.apply(decoratedTree);
     67               
     68        decoratedTree = CombineScopes.apply(decoratedTree);
    6269                               
    6370                return decoratedTree;
     
    6572        }
    6673
    67         public BuiltinEncoder getBuiltinEncoder() {
     74        public PabloSBuiltinEncoder getBuiltinEncoder() {
    6875                return this.builtinEncoder;
    6976        }
    7077
    71         public void setBuiltins2Lang(BuiltinEncoder builtins2Lang) {
     78        public void setBuiltins2Lang(PabloSBuiltinEncoder builtins2Lang) {
    7279                this.builtinEncoder = builtins2Lang;
    7380        }
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/CombineScopes.java

    r3338 r3345  
    1818import pabloS.ast.*;
    1919import pabloS.inputHandler.Locator;
     20import pabloS.logging.ScatterLogger;
    2021import toolchain.pabloS.ast.Accessors;
    2122import toolchain.pabloS.ast.Generators;
    2223import toolchain.pabloS.ast.Mutators;
     24import toolchain.pabloS.lang.type.StreamType;
     25import toolchain.pabloS.lang.type.Type;
     26import toolchain.pabloS.semanticAnalyzer.Binding;
     27import toolchain.pabloS.semanticAnalyzer.SymbolTable;
     28import toolchain.util.Labeller;
    2329
    2430public class CombineScopes {
     
    2834            ASTNode xASTree = SplitVarDeclInits.apply(ASTree);
    2935           
    30             // KH: TODO - not yet implemented, requires support from the semantic analyzer
    31             //SubstituteMangledNamesVisitor substituter = new SubstituteMangledNamesVisitor();
    32             //transformASTree.accept(substituter);
    33 
    34         // KH: tested
    35             //CombineVarDeclsVisitor combiner = new CombineVarDeclsVisitor();
    36             //transformASTree.accept(combiner);
     36            InstallVarDeclBindingsVisitor installer = new InstallVarDeclBindingsVisitor();
     37            xASTree.accept(installer);
     38           
     39            SubstituteMangledNamesVisitor mangler = new SubstituteMangledNamesVisitor();
     40            xASTree.accept(mangler);
     41
     42            CombineVarDeclsVisitor combiner = new CombineVarDeclsVisitor();
     43            xASTree.accept(combiner);
    3744           
    3845                return xASTree;                         
    3946        }   
    4047
     48    static private class InstallVarDeclBindingsVisitor extends VoidVisitor.Default {
     49
     50        private Labeller labeller;
     51       
     52        public void visitEnter(FuncDefNode node) {
     53            node.setSymbolTable(new SymbolTable());
     54            labeller = new Labeller("_v");
     55        }
     56
     57        public void visitEnter(ProgramNode node) {
     58            node.setSymbolTable(new SymbolTable());
     59        }
     60       
     61        public void visitEnter(StructDeclNode node) {
     62            node.setSymbolTable(new SymbolTable());
     63        }
     64       
     65        public void visitEnter(BlockStmtNode node) {
     66            node.setSymbolTable(new SymbolTable());
     67        }
     68       
     69        public void visitLeave(VarDeclNode node) {
     70             
     71            SymbolTable symbolTable = findEnclosingSymbolTable(node);
     72           
     73            String varName = Accessors.varDeclName(node);
     74           
     75            if(symbolTable.hasBinding(varName)) {
     76                multipleDefinitionError(node, varName);
     77            }
     78
     79            Binding binding = Binding.make(varName, node.getType() );
     80            String mangledName = varName + labeller.newLabel();
     81            binding.setMangledName(mangledName);
     82            symbolTable.add(binding);
     83
     84        }
     85       
     86        public void visitLeave(StreamTypeNode node) {
     87            Type type = StreamType.STREAM(node.getFieldWidth());
     88            node.setType(type);
     89        }
     90       
     91        private SymbolTable findEnclosingSymbolTable(ASTNode node) {
     92            ASTNode parent = node.getParent();
     93            while(parent != ASTNode.NO_PARENT) {
     94                if( parent instanceof HasSymbolTableNodeType) {
     95                    return ((HasSymbolTableNodeType)parent).getSymbolTable();
     96                }
     97                parent = parent.getParent();
     98            }
     99            assert false : "Symbol table not found.";
     100            return SymbolTable.getNullInstance();
     101        }
     102       
     103        private void multipleDefinitionError(ASTNode node, String variableName) {
     104            combineScopes(node, "identifier " + variableName + " multiply defined.");
     105        }
     106       
     107        private void combineScopes(Locator locator, String errorDescription) {
     108            ScatterLogger log = ScatterLogger.getLogger("pabloS.CombineScopes");
     109            String message = "" + locator.getLocation() + ": " + "semantic error--" + errorDescription;
     110            log.severe(message);
     111        }
     112    }   
     113       
    41114
    42115    static private class SubstituteMangledNamesVisitor extends VoidVisitor.Default {
    43116
     117        public void visitLeave(CompoundIdentifierNode node) {
     118            node.skipChildren();
     119        }
     120       
    44121        public void visitLeave(IdentifierNode node) {
    45122            // KH: logic, if hasMangledName, substitute mangled name for normal name
    46         }
    47        
     123            if(node.getParent() instanceof FuncDefNode) {
     124                // no action
     125            } else if (node.getParent() instanceof ParameterNode) {
     126                // no action
     127            } else if (node.getParent() instanceof StructTypeNode) {
     128                // no action
     129            } else if (node.getParent() instanceof StructDeclNode) {
     130                // no action
     131            } else if (node.getParent() instanceof StructMemberNode) {
     132                // no action
     133            } else if (node.getParent() instanceof CompoundIdentifierNode) {
     134                // no action
     135            } else if (node.getParent() instanceof FuncCallNode) {
     136                // no action
     137            } else if (Accessors.name(node).startsWith("carry_set")) {
     138                // no action
     139            } else if (Accessors.name(node).equals("EOF_mask")) {
     140                // no action
     141            } else {
     142             
     143                Binding binding = bindingOrError(node,node);
     144                Locator locator = node;
     145                IdentifierNode replacement = Generators.makeIdentifierNode(locator, binding.getMangledName());
     146                node.updateSelf(replacement);
     147
     148            }
     149        }
     150       
     151        private Binding bindingOrError(ASTNode startNode, ASTNode nameNode) {
     152            String name = Accessors.lexeme(nameNode);   
     153            for(ASTNode ancestor: startNode.pathToRoot()) {
     154                if(ancestor instanceof HasSymbolTableNodeType) {
     155                    SymbolTable symbolTable = ((HasSymbolTableNodeType) ancestor).getSymbolTable();
     156                    if(symbolTable.hasBinding(name)) {
     157                        return symbolTable.bindingFor(name);
     158                    }
     159                }
     160            }
     161            combineScopes(startNode, "undefined identifier: " + name);
     162            return Binding.getNullInstance();
     163        }
     164       
     165        private void combineScopes(Locator locator, String errorDescription) {
     166            ScatterLogger log = ScatterLogger.getLogger("pabloS.CombineScopes");
     167            String message = "" + locator.getLocation() + ": " + "semantic error--" + errorDescription;
     168            log.severe(message);
     169        }
    48170    }
    49    
    50 
    51171   
    52172    static private class CombineVarDeclsVisitor extends VoidVisitor.Default {
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/PabloS2PabloBXFormer.java

    r3327 r3345  
    1919import toolchain.pabloB.lang.KernelState;
    2020import toolchain.pabloS.lang.BuiltinCallUtil;
    21 import toolchain.pabloS.lang.carrySet.CarrySetBuiltins;
     21import toolchain.pabloS.lang.carrySet.CarrySetBuiltin;
    2222import toolchain.pabloS.lang.carrySet.CarrySetEncoder;
    2323
     
    155155        FuncCallNode carryFlipFuncCall  = Generators.makeFuncCallNode(locator,
    156156                                                                    CarrySetEncoder.CARRYSETBASENAME,
    157                                                                     carrySetEncoder.getCode(CarrySetBuiltins.CARRYFLIP),
     157                                                                    carrySetEncoder.getName(CarrySetBuiltin.CARRYFLIP),
    158158                                                                    indexNode);
    159159       
    160160        FuncCallNode setCarryFuncCall   = Generators.makeFuncCallNode(locator,
    161161                                                                    CarrySetEncoder.CARRYSETBASENAME,
    162                                                                     carrySetEncoder.getCode(CarrySetBuiltins.SETCARRY),
     162                                                                    carrySetEncoder.getName(CarrySetBuiltin.SETCARRY),
    163163                                                                    carryFlipFuncCall,
    164164                                                                    indexNode);
     
    173173     
    174174        FuncCallNode carryDeclareFuncCall       =   Generators.makeFuncCallNode(locator,
    175                                                                                    carrySetEncoder.getCode(CarrySetBuiltins.CARRYDECLARE), carrySetBaseName, carry1CountNode, carryNCountNode);
     175                                                                                   carrySetEncoder.getName(CarrySetBuiltin.CARRYDECLARE), carrySetBaseName, carry1CountNode, carryNCountNode);
    176176        return carryDeclareFuncCall;
    177177    }
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/SurroundAssert0sWithIfs.java

    r3340 r3345  
    1313import toolchain.pabloS.ast.Accessors;
    1414import toolchain.pabloS.ast.Generators;
    15 import toolchain.pabloS.lang.BuiltinEncoder;
     15import toolchain.pabloS.lang.PabloSBuiltinEncoder;
    1616import toolchain.pabloS.lang.PabloSBuiltin;
    1717import toolchain.pabloS.lang.BuiltinCallUtil;
     
    2828//
    2929public class SurroundAssert0sWithIfs {
    30         static public ASTNode apply(ASTNode ASTree, BuiltinEncoder encoder) {
     30        static public ASTNode apply(ASTNode ASTree, PabloSBuiltinEncoder encoder) {
    3131                XFormer xformer = new XFormer(encoder);
    3232                ASTree.accept(xformer);
     
    3535                               
    3636        static private class XFormer extends VoidVisitor.Default {
    37                 private final BuiltinEncoder encoder;
    38                 private XFormer(BuiltinEncoder encoder) {
     37                private final PabloSBuiltinEncoder encoder;
     38                private XFormer(PabloSBuiltinEncoder encoder) {
    3939                        this.encoder = encoder;
    4040                }
     
    5858                                ASTNode assert0Call
    5959                                                = Generators.makeFuncCallNode(locator,
    60                                                                                                           encoder.getCode(PabloSBuiltin.ASSERT_ZERO),
     60                                                                                                          encoder.getName(PabloSBuiltin.ASSERT_ZERO),
    6161                                                                                                          errorStream,                         
    6262                                                                                                          errorMsg);           
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/CarryBuiltinTranslator.java

    r3337 r3345  
    1212import toolchain.pabloS.lang.PabloSBuiltin;
    1313import toolchain.pabloS.lang.BuiltinCallUtil;
     14import toolchain.pabloS.lang.carrySet.CarrySetBuiltin;
    1415
    1516// BuiltinTranslators translate a builtin call from pabloS to pabloB during the
     
    2122public enum CarryBuiltinTranslator implements BuiltinTranslator {
    2223        CARRY_TRANSLATION {     
    23                 public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context, ASTNode returnValue) {
     24                public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context, ASTNode returnValue) {
    2425            List<ASTNode> arguments = Accessors.argsList(node);
    2526            Locator locator = node;
    26             replaceCallWithPabloBlkCall(node, context.getCode(translatedBuiltin), arguments, counter.makeGetCarryCall(locator, context), returnValue);
     27            replaceCallWithPabloBlkCall(node,
     28                                        context.getCode(builtin),
     29                                        arguments,
     30                                        Generators.makeGetCallCarryForBuiltin(locator, builtin, counter.value(), context),
     31                                        returnValue);
    2732                }
    2833        },
     
    3843                    Locator locator = node;
    3944                   
    40                     replaceCallWithPabloBlkCall(node, formattedAdvanceN, arguments, counter.makeGetCarryCall(locator, context), returnValue);
     45                    replaceCallWithPabloBlkCall(node,
     46                                                formattedAdvanceN,
     47                                                arguments,
     48                                                Generators.makeGetCallCarryForBuiltin(locator, builtin, counter.value(), context), 
     49                                                returnValue);
    4150                }
    4251
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/CarryIntroXFormer.java

    r3338 r3345  
    99import toolchain.pabloS.ast.Generators;
    1010import toolchain.pabloS.lang.*;
    11 import toolchain.pabloS.lang.carrySet.CarrySetBuiltins;
     11import toolchain.pabloS.lang.carrySet.CarrySetBuiltin;
    1212import toolchain.pabloS.lang.carrySet.CarrySetEncoder;
    1313import toolchain.pabloS.transformer.visitors.carry.CarryNoneBuiltinTranslator;
     
    7070        if(!isTempified) {
    7171            isTempified = true;
    72             return TempifyCarryBuiltinCalls.apply(ASTree);
     72            return TempifyCarrySetBuiltinCalls.apply(ASTree);
    7373        }
    7474        return ASTree;
    7575    }
    7676   
    77     public static ASTNode apply(ASTNode root, BuiltinEncoder builtinEncoder, CarrySetEncoder carrySetEncoder, boolean finalBlockMode) {
     77    public static ASTNode apply(ASTNode root, PabloSBuiltinEncoder builtinEncoder, CarrySetEncoder carrySetEncoder, boolean finalBlockMode) {
    7878       
    7979        ASTNode xTree = apply(root, builtinEncoder, carrySetEncoder, finalBlockMode, true, 0);
     
    8282    }
    8383
    84     private static ASTNode apply(ASTNode root, BuiltinEncoder builtinEncoder, CarrySetEncoder carrySetEncoder,
     84    private static ASTNode apply(ASTNode root, PabloSBuiltinEncoder builtinEncoder, CarrySetEncoder carrySetEncoder,
    8585                                boolean finalBlockMode, boolean ciMode, int carrySetDepth) {
    8686        Context context = new Context(builtinEncoder, carrySetEncoder, ciMode, finalBlockMode, carrySetDepth);
     
    104104    static private class Transformer extends VoidVisitor.Default {
    105105        private Context context;
    106         private Counter carryCounter    = new Counter(CarrySetBuiltins.GETCARRY);
    107         private Counter advanceNCounter = new Counter(CarrySetBuiltins.PENDING64);
     106        private Counter carryCounter    = new Counter();
     107        private Counter advanceNCounter = new Counter();
    108108       
    109109        Transformer(Context context) {
     
    158158                                                                        location,
    159159                                                                        context.getCarrySetIdentifier(),                                                                       
    160                                                                         context.getCarrySetEncoder().getCode(CarrySetBuiltins.CARRYADJUST),
    161                                                                         arguments(carry1CountNode));
     160                                                                        context.getCarrySetEncoder().getName(CarrySetBuiltin.CARRYADJUST),
     161                                                                        Generators.arguments(carry1CountNode));
    162162                        return carryAdjustment;
    163163                }
     
    179179                translator.translate(builtin, funcCall, counter, context, returnValue.deepCopy());
    180180               
    181                 node.replaceChild(lhs, counter.makeGetCarryCall(node,context));
     181                Locator locator = node;
     182                node.replaceChild(lhs, Generators.makeGetCallCarryForBuiltin(locator, builtin, counter.value(), context));
     183               
    182184                counter.increment();
    183185                    }
     
    201203                            translator.translate(builtin, funcCall, counter, context, returnValue);
    202204
    203                             node.replaceChild(lhs, counter.makeGetCarryCall(node,context));
     205                            Locator locator = node;
     206                            node.replaceChild(lhs, Generators.makeGetCallCarryForBuiltin(locator, builtin, counter.value(), context));
     207                           
    204208                            counter.increment();
    205209                        }
     
    263267                                                                location,
    264268                                                                context.getCarrySetIdentifier(),
    265                                                                 context.getCarrySetEncoder().getCode(CarrySetBuiltins.CARRYDEQUEUEENQUEUE),
    266                                                                 arguments(carryBaseNode, carryCountNode));
     269                                                                context.getCarrySetEncoder().getName(CarrySetBuiltin.CARRYDEQUEUEENQUEUE),
     270                                                                Generators.arguments(carryBaseNode, carryCountNode));
    267271                        return carryDequeueEnqueue;
    268272                }
     
    372376                                                                        locator,
    373377                                                                        context.getCarrySetIdentifier(),
    374                                                                         context.getCarrySetEncoder().getCode(CarrySetBuiltins.CARRYDEQUEUEENQUEUE),
    375                                                                         arguments(carryBaseNode, carry1CountNode));
     378                                                                        context.getCarrySetEncoder().getName(CarrySetBuiltin.CARRYDEQUEUEENQUEUE),
     379                                                                        Generators.arguments(carryBaseNode, carry1CountNode));
    376380                       
    377381                                               
     
    436440                        FuncCallNode carryDeclare = Generators.makeFuncCallNode(
    437441                                                                location,
    438                                                                 context.getCode(CarrySetBuiltins.CARRYDECLARE),
     442                                                                context.getCode(CarrySetBuiltin.CARRYDECLARE),
    439443                                                                localCarrySetIdentifierNode, leaf(carry1Count, location), leaf(carryNCount, location));
    440444                        return carryDeclare;
     
    449453                        return Generators.makeFuncCallNode(
    450454                                                locator,
    451                                                 context.getCode(CarrySetBuiltins.LOCALCARRYCOMBINE),
    452                                                 arguments(context.carrySetIdentifierNode(locator),
     455                                                context.getCode(CarrySetBuiltin.LOCALCARRYCOMBINE),
     456                                                Generators.arguments(context.carrySetIdentifierNode(locator),
    453457                                                                  localCarrySetIdentifierNode,
    454458                                                                  carryBaseNode,
     
    471475                                                                        location,
    472476                                                                        context.getCarrySetIdentifier(),
    473                                                                         context.getCarrySetEncoder().getCode(CarrySetBuiltins.CARRYRANGE),
    474                                                                         arguments(carryBaseNode, carryCountNode));
     477                                                                        context.getCarrySetEncoder().getName(CarrySetBuiltin.CARRYRANGE),
     478                                                                        Generators.arguments(carryBaseNode, carryCountNode));
    475479
    476480                        LextantToken or = Generators.makeLextantToken(condition, Lextant.OR);
     
    482486                ///////////////////////////////////////////////////////////////////
    483487                // Utilities
    484                
    485                 private ASTNode[] arguments(ASTNode...astNodes) {
    486                         return astNodes;
    487                 }
    488488                public IntegerConstantNode leaf(int n, Locator locator) {
    489489                        return Generators.makeIntegerConstantNode(locator, n);
    490490                }               
    491491        }
    492 
    493 
    494492}       
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/CarryNoneBuiltinTranslator.java

    r3325 r3345  
    33import pabloS.ast.ASTNode;
    44import pabloS.ast.FuncCallNode;
     5import pabloS.inputHandler.Locator;
    56import toolchain.pabloS.ast.Accessors;
    67import toolchain.pabloS.ast.Generators;
     
    1819                public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
    1920                        if(context.isFinalBlockMode()) {
    20                                 ASTNode argNode = Accessors.argument(node, 0);
    21                                 ASTNode replacementNode = Generators.makeSIMDAndCEOFMaskFuncCall(argNode, context.getBuiltinEncoder());
    22                                 node.updateSelf(replacementNode);
     21                                ASTNode arg = Accessors.argument(node, 0);
     22                                ASTNode replacement = Generators.makeSIMDAndCEOFMaskFuncCall(arg, context.getBuiltinEncoder());
     23                                node.updateSelf(replacement);
    2324                        }
    2425                        else {                         
    25                                 node.updateSelf(counter.mask(node));                   
     26                            Locator locator = node;
     27                            ASTNode maskCall = Generators.makeMaskFuncCall(locator, 1, 0);
     28                                node.updateSelf(maskCall);                     
    2629                        }
    2730                }
     
    3134                public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
    3235                        if(context.isFinalBlockMode()) {                                       
    33                                 ASTNode argNode = Accessors.argument(node, 0);
    34                                 ASTNode replacementNode = Generators.makeSIMDAndEOFMaskFuncCall(argNode, context.getBuiltinEncoder());
    35                                 node.updateSelf(replacementNode);
     36                                ASTNode arg = Accessors.argument(node, 0);
     37                                ASTNode replacement = Generators.makeSIMDAndEOFMaskFuncCall(arg, context.getBuiltinEncoder());
     38                                node.updateSelf(replacement);
    3639                        } else {
    3740                                node.updateSelf(Accessors.argument(node,0));
     
    4245        MASK_TRANSLATION {
    4346                public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
    44                         node.updateSelf(counter.mask(node));
     47            Locator locator = node;
     48            ASTNode maskCall = Generators.makeMaskFuncCall(locator, 1, 0);
     49            node.updateSelf(maskCall);     
    4550                }
    4651        };
    4752
    48         abstract public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context);
     53        abstract public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context);
    4954               
    5055}
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/Context.java

    r3271 r3345  
    44import pabloS.inputHandler.Locator;
    55import toolchain.pabloS.ast.Generators;
    6 import toolchain.pabloS.lang.BuiltinEncoder;
     6import toolchain.pabloS.lang.PabloSBuiltinEncoder;
    77import toolchain.pabloS.lang.PabloSBuiltin;
    8 import toolchain.pabloS.lang.carrySet.CarrySetBuiltins;
     8import toolchain.pabloS.lang.carrySet.CarrySetBuiltin;
    99import toolchain.pabloS.lang.carrySet.CarrySetEncoder;
    1010
     
    1313        final private boolean carryInMode;
    1414        final private boolean finalBlockMode;
    15         final private BuiltinEncoder builtinEncoder;
     15        final private PabloSBuiltinEncoder builtinEncoder;
    1616        final private CarrySetEncoder carrySetEncoder;
    1717        final private int carrySetDepth;
    1818       
    19         public Context(BuiltinEncoder builtinEncoder, CarrySetEncoder carrySetEncoder,
     19        public Context(PabloSBuiltinEncoder builtinEncoder, CarrySetEncoder carrySetEncoder) {
     20            this(builtinEncoder, carrySetEncoder, true, false, 0);
     21        }
     22       
     23        public Context(PabloSBuiltinEncoder builtinEncoder, CarrySetEncoder carrySetEncoder,
    2024                        boolean carryInMode, boolean finalBlockMode,
    2125                        int carrySetDepth) {
     
    3539                return finalBlockMode;
    3640        }
    37         public final BuiltinEncoder getBuiltinEncoder() {
     41        public final PabloSBuiltinEncoder getBuiltinEncoder() {
    3842                return builtinEncoder;
    3943        }
     
    5458                return Generators.makeIdentifierNode(location, getCarrySetIdentifier());
    5559        }
    56         public final String getCode(CarrySetBuiltins carrySetBuiltin) {
    57                 return getCarrySetEncoder().getCode(carrySetBuiltin);
     60        public final String getCode(CarrySetBuiltin carrySetBuiltin) {
     61                return getCarrySetEncoder().getName(carrySetBuiltin);
    5862        }
    5963        public final String getCode(PabloSBuiltin builtin) {
    60                 return getBuiltinEncoder().getCode(builtin);
     64                return getBuiltinEncoder().getName(builtin);
    6165        }
    6266       
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/Counter.java

    r3327 r3345  
    11package toolchain.pabloS.transformer.visitors.carry;
    22
    3 import pabloS.ast.ASTNode;
    43import pabloS.ast.IntegerConstantNode;
    54import pabloS.inputHandler.Locator;
    65import toolchain.pabloS.ast.Generators;
    7 import toolchain.pabloS.lang.carrySet.CarrySetBuiltins;
    8 
    96
    107public class Counter {
    118        private int count;
    12         private CarrySetBuiltins builtin;
    13        
    14         public Counter(CarrySetBuiltins builtin) {
    15                 this.builtin = builtin;
    16         }
    179        public void reset() {
    1810                count = 0;
     
    3022                return Generators.makeIntegerConstantNode(locator, value());
    3123        }
    32         public ASTNode callOrMask(Locator locator, Context context) {
    33                 if(context.isCarryInMode()) {
    34                         return makeGetCarryCall(locator, context);
    35                 }
    36                 else {
    37                         return mask(locator);
    38                 }
    39         }
    40         public ASTNode makeGetCarryCall(Locator locator, Context context) {
    41             return Generators.makeFuncCallNode(
    42                 locator,
    43                 context.getCarrySetIdentifier(),
    44                 context.getCarrySetEncoder().getCode(builtin),
    45                 valueNode(locator));
    46         }
    47         public ASTNode mask(Locator locator) {
    48                 return Generators.makeMaskFuncCall(locator, 1, 0);
    49         }
     24
    5025}
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/TempifyCarrySetBuiltinCalls.java

    r3338 r3345  
    5959
    6060import toolchain.pabloS.transformer.visitors.*;
    61 public class TempifyCarryBuiltinCalls {
     61public class TempifyCarrySetBuiltinCalls {
    6262       
    6363        static public ASTNode apply(ASTNode ASTree) {
Note: See TracChangeset for help on using the changeset viewer.