Changeset 2655


Ignore:
Timestamp:
Nov 19, 2012, 2:44:53 PM (6 years ago)
Author:
ksherdy
Message:

Added command line options configuration class. Refactored compiler to support multiple target languages (C/C++).

Location:
proto/pablo
Files:
3 added
1 deleted
5 edited
5 moved

Legend:

Unmodified
Added
Removed
  • proto/pablo/runConfigurations/pabloCompiler.launch

    r2654 r2655  
    99</listAttribute>
    1010<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="compiler.PabloCompiler"/>
    11 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="--input ${workspace_loc}/pablo/input/test/pablo/py2pablo/parabix2_pablo.pablo.exclude -a"/>
     11<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="--input ${workspace_loc}/pablo/input/test/pablo/py2pablo/parabix2_pablo.pablo.exclude -a -d"/>
    1212<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="pablo"/>
    1313<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-ea"/>
  • proto/pablo/src/compiler/OptionsConfig.java

    r2654 r2655  
    77import org.apache.commons.cli.Options;
    88
    9 public class Config {   
     9public class OptionsConfig {   
    1010       
    1111          public static Options createOptions() {
     
    1414                    Option option;
    1515
    16                     // help     
    1716                    OptionBuilder.hasArg(false);
    1817                    OptionBuilder.isRequired(false);
     
    2221                        options.addOption(option);
    2322                       
    24                     // input file
    2523                    OptionBuilder.hasArg(true);
    2624                    OptionBuilder.isRequired(true);
     
    3028                    options.addOption(option);
    3129
    32                     // template file
    3330                    OptionBuilder.hasArg(true);
    3431                    OptionBuilder.isRequired(false);
     
    3835                    options.addOption(option);
    3936                                                   
    40                     // output directory
    4137                    OptionBuilder.hasArg(true);
    4238                    OptionBuilder.isRequired(false);
     
    4642                        options.addOption(option);
    4743                       
    48                         // error routine
    4944                    OptionBuilder.hasArg(true);
    5045                    OptionBuilder.isRequired(false);
     
    5449                        options.addOption(option);
    5550
    56                         // SIMD register dump statements
    5751                    OptionBuilder.hasArg(false);
    5852                    OptionBuilder.isRequired(false);
    59                     //OptionBuilder.withLongOpt("add");
     53                    OptionBuilder.withLongOpt("dump");
    6054                    OptionBuilder.withDescription("Add SIMD register dump statements.");
     55                        option = OptionBuilder.create("d");
     56                        options.addOption(option);                     
     57
     58                    OptionBuilder.hasArg(false);
     59                    OptionBuilder.isRequired(false);
     60                    OptionBuilder.withLongOpt("align");
     61                    OptionBuilder.withDescription("Add ASSERT_BITBLOCK_ALIGN statements.");
    6162                        option = OptionBuilder.create("a");
    6263                        options.addOption(option);                     
     64                       
    6365                       
    6466                        // TODO - Add options as needed.
  • proto/pablo/src/compiler/PabloCompiler.java

    r2654 r2655  
    1212import  logging.ScatterLogger;
    1313import compiler.lang.idisa.*;
     14import compiler.lang.pablo.builtins.Builtins2CPP;
     15import compiler.lang.pablo.builtins.Builtins2Lang;
    1416import compiler.visitors.*;
    1517//import semanticAnalyzer.SampleSemanticAnalyzer;
     
    3638       
    3739        private static boolean addDumpStatements = false;
     40        private static boolean addAssertBitBlockAlignStatements = false;
    3841               
    3942        public static void main(String[] args) throws FileNotFoundException {
    4043       
    41                 Options options = Config.createOptions();
     44                Options options = OptionsConfig.createOptions();
    4245               
    4346                try {
     
    4952                    errorRoutine = cmd.getOptionValue("e", "assert_0_error");
    5053                   
    51                     if(cmd.hasOption("a")) {
    52                         addDumpStatements = true;
    53                     }
     54                    if(cmd.hasOption("d")) { addDumpStatements = true; }
     55                    if(cmd.hasOption("a")) { addAssertBitBlockAlignStatements = true; }
    5456                       
    5557                } catch (Exception e) {
    5658                        //e.printStackTrace();
    57                         Config.exitWithUsageMessage(options);
     59                        OptionsConfig.exitWithUsageMessage(options);
    5860                }
    5961               
     
    7476                Map<String, ASTNode> streamFunctionMap = streamFunctionVisitor.makeStreamFunctionMap();
    7577               
     78                Builtins2Lang builtins2CPP = new Builtins2CPP();
     79               
    7680                for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {
    7781                       
    78                     AdvanceCombinerTransformer advanceCombiner = new AdvanceCombinerTransformer(entry.getValue());
     82                    ASTNode value = entry.getValue();
     83                       
     84                    AdvanceCombinerTransformer advanceCombiner = new AdvanceCombinerTransformer(value);
    7985                    advanceCombiner.transform();
    8086                   
     
    8995                        */
    9096                       
    91                     AugmentedAssignmentTransformer augmentedAssignment = new AugmentedAssignmentTransformer(entry.getValue());
     97                    AugmentedAssignmentTransformer augmentedAssignment = new AugmentedAssignmentTransformer(value);
    9298                        augmentedAssignment.transform();
    9399                       
     100                        CarryIntroTransformer carryQIntro = new CarryIntroTransformer(value);
     101                        carryQIntro.transform(true, false);
     102                       
     103                        Pablo2CarryTransformer pablo2CarryQ = new Pablo2CarryTransformer(value, builtins2CPP);
     104                        pablo2CarryQ.transform(true, false);               
     105                   
     106                        Bitwise2IDISATransformer bitwiseToIDISA = new Bitwise2IDISATransformer(value);
     107                        bitwiseToIDISA.transform();
     108
    94109                        if(PabloCompiler.addDumpStatements) {
    95                                 DumpAssignmentStatementsTransformer dumpAssignmentStatementsTransformer = new DumpAssignmentStatementsTransformer(entry.getValue()); 
     110                                DumpAssignmentStatementsTransformer dumpAssignmentStatementsTransformer
     111                                        = new DumpAssignmentStatementsTransformer(value, builtins2CPP); 
    96112                                dumpAssignmentStatementsTransformer.transform();
    97113                        }
    98114                       
    99                         CarryQIntroTransformer carryQIntro = new CarryQIntroTransformer(entry.getValue());
    100                         carryQIntro.transform(true, false);
     115                        if(PabloCompiler.addAssertBitBlockAlignStatements) {
     116                                AssertBitBlockAlignStatementsTransformer assertBitBlockAlignStatementsTransformer
     117                                        = new AssertBitBlockAlignStatementsTransformer(value, builtins2CPP); 
     118                                assertBitBlockAlignStatementsTransformer.transform();
     119                        }                       
    101120                       
    102                         Pablo2CarryQTransformer pablo2CarryQ = new Pablo2CarryQTransformer(entry.getValue());
    103                         pablo2CarryQ.transform(true, false);               
    104                    
    105                         Bitwise2IDISATransformer bitwiseToIDISA = new Bitwise2IDISATransformer(entry.getValue());
    106                         bitwiseToIDISA.transform();
    107                        
    108                         Unparser cPPUnparser = new CPPUnparser(entry.getValue());
     121                        Unparser cPPUnparser = new CPPUnparser(value);
    109122                        String code = cPPUnparser.getCode();
    110123                        System.out.print(code);
  • proto/pablo/src/compiler/PabloCompilerTestHarness.java

    r2651 r2655  
    2020
    2121import compiler.lang.idisa.*;
     22import compiler.lang.pablo.builtins.Builtins2CPP;
     23import compiler.lang.pablo.builtins.Builtins2Lang;
    2224import compiler.visitors.*;
    2325import compiler.test.*;
     
    185187                ASTNode syntaxTree = Parser.parse(lexController);
    186188               
     189               
    187190                StreamFunctionVisitor streamFunctionVisitor = new StreamFunctionVisitor(syntaxTree);
    188191                Map<String, ASTNode> streamFunctionMap = streamFunctionVisitor.makeStreamFunctionMap();
    189192               
     193                Builtins2Lang builtins2CPP = new Builtins2CPP();
     194               
    190195                for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {
    191                                                
    192                         Pablo2CarryQTransformer pablo2CarryQ = new Pablo2CarryQTransformer(entry.getValue());
     196                        ASTNode value = entry.getValue();                               
     197                       
     198                        Pablo2CarryTransformer pablo2CarryQ = new Pablo2CarryTransformer(value, builtins2CPP);
    193199                        pablo2CarryQ.transform(ciMode, coMode);                 
    194200                       
  • proto/pablo/src/compiler/lang/pablo/builtins/Builtins.java

    r2641 r2655  
    44import java.util.List;
    55
     6public enum Builtins {
    67
     8    ADVANCE(Carry.One, "Advance", 1),
     9    SCANTOFIRST(Carry.One, "ScanToFirst", 1),
     10    SCANTHRU(Carry.One, "ScanThru", 2),
     11    SCANTO(Carry.One, "ScanTo", 2),
     12    ADVANCETHENSCANTHRU(Carry.One, "AdvanceThenScanThru", 2),
     13    ADVANCETHENSCANTO(Carry.One, "AdvanceThenScanTo", 2),
     14    SPANUPTO(Carry.One, "SpanUpTo", 2),
     15    INCLUSIVESPAN(Carry.One, "InclusiveSpan", 2),
     16    EXCLUSIVESPAN(Carry.One, "ExclusiveSpan", 2),   
    717
    8 public enum BuiltinOperations {
     18    ADVANCE32(Carry.N, "Advance32", 1),
     19    ADVANCEN(Carry.N, "Advance", 2),
    920
    10     ADVANCE(Carry.One, "Advance", 1, "BitBlock_advance_ci_co"),
    11     SCANTOFIRST(Carry.One, "ScanToFirst", 1, "BitBlock_scantofirst"),
    12     SCANTHRU(Carry.One, "ScanThru", 2, "BitBlock_scanthru_ci_co"),
    13     SCANTO(Carry.One, "ScanTo", 2, "BitBlock_scanto_ci_co"),
    14     ADVANCETHENSCANTHRU(Carry.One, "AdvanceThenScanThru", 2, "BitBlock_advance_then_scanthru"),
    15     ADVANCETHENSCANTO(Carry.One, "AdvanceThenScanTo", 2, "BitBlock_advance_then_scanto"),
    16     SPANUPTO(Carry.One, "SpanUpTo", 2, "BitBlock_span_upto"),
    17     INCLUSIVESPAN(Carry.One, "InclusiveSpan", 2, "BitBlock_inclusive_span"),
    18     EXCLUSIVESPAN(Carry.One, "ExclusiveSpan", 2, "BitBlock_exclusive_span"),   
    19 
    20     ADVANCE32(Carry.N, "Advance32", 1, "BitBlock_advance_n_<32>"),
    21     ADVANCEN(Carry.N, "Advance", 2, "BitBlock_advance_n_<%d>"),
    22 
    23     ATEOF(Carry.None, "atEOF", 1, "atEOF"),
    24     INFILE(Carry.None, "inFile", 1, "inFile"),
     21    ATEOF(Carry.None, "atEOF", 1),
     22    INFILE(Carry.None, "inFile", 1),
     23    EOFMASK(Carry.None, "EOF_mask", 0), // deprecated
    2524       
    26     PRINTBITBLOCK(Carry.None, "PrintBitBlock", 1, "print_register<BitBlock>"); // psuedo builtin
     25    PRINTBITBLOCK(Carry.None, "PrintBitBlock", 1),
     26    ASSERTBITBLOCKALIGN(Carry.None, "AssertBitBlockAlign", 1);
    2727   
    2828    public enum Carry{One, N, None};   
     
    3131        private final String pabloName;
    3232        private final int argCount;
    33         private final String cPPName;
    3433       
    35         private BuiltinOperations(Carry type, String pabloName, int argCount, String cPPName) {
     34        private Builtins(Carry type, String pabloName, int argCount) {
    3635                this.type = type;
    3736                this.pabloName = pabloName;
    3837                this.argCount = argCount;
    39                 this.cPPName = cPPName;
    4038        }
    4139       
    4240        public String pabloName() { return this.pabloName; }
    4341        public int argCount() { return this.argCount; }
    44         public String cPPCode() { return this.cPPName; }
    4542
    46         public static List<BuiltinOperations> carryOneOperations () {
     43        public static List<Builtins> carryOneOperations () {
    4744               
    48                 ArrayList<BuiltinOperations> carryN = new ArrayList<BuiltinOperations>();
     45                ArrayList<Builtins> carryN = new ArrayList<Builtins>();
    4946               
    50                 for (BuiltinOperations operation : BuiltinOperations.values()) {
     47                for (Builtins operation : Builtins.values()) {
    5148                        if (Carry.One == operation.type) {
    5249                                carryN.add(operation);
     
    5754        }       
    5855       
    59         public static List<BuiltinOperations> carryNOperations () {
     56        public static List<Builtins> carryNOperations () {
    6057               
    61                 ArrayList<BuiltinOperations> carryN = new ArrayList<BuiltinOperations>();
     58                ArrayList<Builtins> carryN = new ArrayList<Builtins>();
    6259               
    63                 for (BuiltinOperations operation : BuiltinOperations.values()) {
     60                for (Builtins operation : Builtins.values()) {
    6461                        if (Carry.N == operation.type) {
    6562                                carryN.add(operation);
  • proto/pablo/src/compiler/lang/pablo/builtins/BuiltinsUtil.java

    r2641 r2655  
    2323   
    2424        // Advance(X)
    25         if (isQualifiedName(nameNode, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCE.pabloName())
     25        if (isQualifiedName(nameNode, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCE.pabloName())
    2626                && argumentsListNode.nChildren() == 1) {
    2727            return true;
     
    2929
    3030        // Advance(X,n)
    31         if (isQualifiedName(nameNode, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCE.pabloName())
     31        if (isQualifiedName(nameNode, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCE.pabloName())
    3232                && argumentsListNode.nChildren() == 2) {       
    3333                        return true;
     
    3939    public static boolean isBuiltinOperations(ASTNode node) {
    4040       
    41                 for (BuiltinOperations builtin : BuiltinOperations.values()) {   
     41                for (Builtins builtin : Builtins.values()) {   
    4242                if (isQualifiedName(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, builtin.pabloName())) {
    4343                    return true;
     
    5050    public static boolean isCarryOne(ASTNode node) {
    5151       
    52                 for (BuiltinOperations carryOneOperation : BuiltinOperations.carryOneOperations()) {                           
     52                for (Builtins carryOneOperation : Builtins.carryOneOperations()) {                     
    5353                               
    5454                        ASTNode identifier = Accessors.functionInvocationName((FunctionInvocationNode) node);
     
    6565    public static boolean isCarryN(ASTNode node) {
    6666               
    67                 for (BuiltinOperations carryNOperation : BuiltinOperations.carryNOperations()) {
     67                for (Builtins carryNOperation : Builtins.carryNOperations()) {
    6868                        ASTNode identifier = Accessors.functionInvocationName((FunctionInvocationNode) node);
    6969                        int argCount = Accessors.functionInvocationArgumentCount((FunctionInvocationNode) node);
     
    9393        ASTNode nameNode = Accessors.functionInvocationName(fNode);
    9494
    95         for (BuiltinOperations builtin : BuiltinOperations.values()) {
     95        for (Builtins builtin : Builtins.values()) {
    9696            if (isQualifiedName(nameNode, BuiltinsUtil.BUILTIN_PACKAGE_NAME, builtin.pabloName())) {
    9797                return true;
     
    110110    public static boolean isBuiltInCall(ASTNode node) {
    111111       
    112         for (BuiltinOperations builtin : BuiltinOperations.values()) {   
     112        for (Builtins builtin : Builtins.values()) {   
    113113            if (isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, builtin.pabloName(), builtin.argCount())) {
    114114                return true;
  • proto/pablo/src/compiler/lang/pablo/builtins/CarryQ.java

    r2607 r2655  
    1 package compiler.codeGeneration;
     1package compiler.lang.pablo.builtins;
    22
    33public enum CarryQ {
  • proto/pablo/src/compiler/visitors/CarryIntroTransformer.java

    r2651 r2655  
    55import compiler.ast.Accessors;
    66import compiler.ast.Generators;
    7 import compiler.codeGeneration.CarryQ;
    87import compiler.lang.pablo.builtins.BuiltinsUtil;
     8import compiler.lang.pablo.builtins.CarryQ;
    99
    1010import ast.*;
    1111
    12 public class CarryQIntroTransformer {
     12public class CarryIntroTransformer {
    1313               
    1414        private ASTNode ASTTree; // FunctionDefNode     
    1515               
    16     public CarryQIntroTransformer(ASTNode node) {
     16    public CarryIntroTransformer(ASTNode node) {
    1717        assert node instanceof FunctionDefNode;
    1818        this.ASTTree = node;
  • proto/pablo/src/compiler/visitors/DumpAssignmentStatementsTransformer.java

    r2641 r2655  
    44import compiler.ast.Accessors;
    55import compiler.ast.Generators;
    6 import compiler.lang.pablo.builtins.BuiltinOperations;
     6import compiler.lang.pablo.builtins.Builtins;
     7import compiler.lang.pablo.builtins.Builtins2Lang;
    78
    89public class DumpAssignmentStatementsTransformer {
    910        private ASTNode ASTree;
     11        private Builtins2Lang builtins2Lang;
    1012       
    11         public DumpAssignmentStatementsTransformer(ASTNode ASTree) {
     13        public DumpAssignmentStatementsTransformer(ASTNode ASTree, Builtins2Lang builtins2Lang) {
    1214                this.ASTree = ASTree;
     15                this.builtins2Lang = builtins2Lang;
    1316        }
    1417       
     
    3336                private void addDumpStatement(ASTNode node, ASTNode lhs) {
    3437                        FunctionInvocationNode printRegisterStatement =
    35                                         Generators.makeFunctionInvocationNode(BuiltinOperations.PRINTBITBLOCK.cPPCode(),
     38                                        Generators.makeFunctionInvocationNode(  builtins2Lang.getCode(Builtins.PRINTBITBLOCK),
    3639                                                                                                                        node.getToken(),
    3740                                                                                                                        new ASTNode [] {lhs});
  • proto/pablo/src/compiler/visitors/Pablo2CarryTransformer.java

    r2651 r2655  
    66import compiler.ast.Accessors;
    77import compiler.ast.Generators;
    8 import compiler.codeGeneration.CarryQ;
    98import compiler.lang.idisa.SIMD;
    10 import compiler.lang.pablo.builtins.BuiltinOperations;
    11 import compiler.lang.pablo.builtins.BuiltinsUtil;
    12 import compiler.lang.pablo.builtins.Keywords;
     9import compiler.lang.pablo.builtins.*;
     10
    1311
    1412import ast.*;
    1513
    16 public class Pablo2CarryQTransformer {
     14public class Pablo2CarryTransformer {
    1715               
     16        private Builtins2Lang builtins2Lang;
     17       
    1818        private ASTNode ASTTree; // FunctionDefNode     
    1919       
     
    2323        //    self.carryout = carryout   
    2424       
    25     public Pablo2CarryQTransformer(ASTNode node) {
     25    public Pablo2CarryTransformer(ASTNode node, Builtins2Lang builtins2Lang) {
    2626        assert node instanceof FunctionDefNode;
    2727        this.ASTTree = node;
     28        this.builtins2Lang = builtins2Lang;
    2829    }
    2930
     
    114115        //                    self.current_carry += 1
    115116        //                    return c                 
    116                         if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCE.pabloName(), BuiltinOperations.ADVANCE.argCount())) {               
    117                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE.cPPCode(), carryCall, currentCarry);
     117                        if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCE.pabloName(), Builtins.ADVANCE.argCount())) {         
     118                                replaceFunctionInvocationNode(node,
     119                                                CarryQ.CarryQ_PACKAGE_NAME,
     120                                                builtins2Lang.getCode(Builtins.ADVANCE),
     121                                                carryCall,
     122                                                currentCarry);
    118123                                this.currentCarry += 1;
    119124                        }
     
    125130        //            self.current_carry += 1
    126131        //            return c         
    127                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.SCANTHRU.pabloName(), BuiltinOperations.SCANTHRU.argCount())) {                         
    128                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.SCANTHRU.cPPCode(), carryCall, currentCarry);
     132                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTHRU.pabloName(), Builtins.SCANTHRU.argCount())) {                           
     133                                replaceFunctionInvocationNode(node,
     134                                                CarryQ.CarryQ_PACKAGE_NAME,
     135                                                builtins2Lang.getCode(Builtins.SCANTHRU),
     136                                                carryCall,
     137                                                currentCarry);
    129138                                this.currentCarry += 1;
    130139                        }
     
    136145        //            self.current_carry += 1
    137146        //            return c         
    138                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCETHENSCANTHRU.pabloName(), BuiltinOperations.ADVANCETHENSCANTHRU.argCount())) {
    139                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCETHENSCANTHRU.cPPCode(), carryCall, currentCarry);
     147                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCETHENSCANTHRU.pabloName(), Builtins.ADVANCETHENSCANTHRU.argCount())) {
     148                                replaceFunctionInvocationNode(node,
     149                                                CarryQ.CarryQ_PACKAGE_NAME,
     150                                                builtins2Lang.getCode(Builtins.ADVANCETHENSCANTHRU),
     151                                                carryCall,
     152                                                currentCarry);
    140153                                this.currentCarry += 1;
    141154                        }               
     
    147160        //            self.current_carry += 1
    148161        //            return c         
    149                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.SPANUPTO.pabloName(), BuiltinOperations.SPANUPTO.argCount())) {
    150                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.SPANUPTO.cPPCode(), carryCall, currentCarry);                         
     162                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SPANUPTO.pabloName(), Builtins.SPANUPTO.argCount())) {
     163                                replaceFunctionInvocationNode(node,
     164                                                CarryQ.CarryQ_PACKAGE_NAME,
     165                                                builtins2Lang.getCode(Builtins.SPANUPTO),
     166                                                carryCall,
     167                                                currentCarry);                         
    151168                                this.currentCarry += 1;
    152169                        }               
     
    160177        //            self.current_carry += 1
    161178        //            return c
    162                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCETHENSCANTO.pabloName(), BuiltinOperations.ADVANCETHENSCANTO.argCount())) {
    163                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCETHENSCANTO.cPPCode(), carryCall, currentCarry);
     179                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCETHENSCANTO.pabloName(), Builtins.ADVANCETHENSCANTO.argCount())) {
     180                                replaceFunctionInvocationNode(node,
     181                                                CarryQ.CarryQ_PACKAGE_NAME,
     182                                                builtins2Lang.getCode(Builtins.ADVANCETHENSCANTO),
     183                                                carryCall,
     184                                                currentCarry);
    164185                                this.currentCarry += 1;
    165186                        }               
     
    174195        //            return c
    175196       
    176                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.INCLUSIVESPAN.pabloName(), BuiltinOperations.INCLUSIVESPAN.argCount())) {
    177                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.INCLUSIVESPAN.cPPCode(), carryCall, currentCarry);
     197                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.INCLUSIVESPAN.pabloName(), Builtins.INCLUSIVESPAN.argCount())) {
     198                                replaceFunctionInvocationNode(node,
     199                                                CarryQ.CarryQ_PACKAGE_NAME,
     200                                                builtins2Lang.getCode(Builtins.INCLUSIVESPAN),
     201                                                carryCall,
     202                                                currentCarry);
    178203                                this.currentCarry += 1;
    179204                        }                               
     
    188213        //            return c
    189214       
    190                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.EXCLUSIVESPAN.pabloName(), BuiltinOperations.EXCLUSIVESPAN.argCount())) {
    191                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.EXCLUSIVESPAN.cPPCode(), carryCall, currentCarry);
     215                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.EXCLUSIVESPAN.pabloName(), Builtins.EXCLUSIVESPAN.argCount())) {
     216                                replaceFunctionInvocationNode(node,
     217                                                CarryQ.CarryQ_PACKAGE_NAME,
     218                                                builtins2Lang.getCode(Builtins.EXCLUSIVESPAN),
     219                                                carryCall,
     220                                                currentCarry);
    192221                                this.currentCarry += 1;
    193222                        }                                               
     
    204233        //            return c
    205234       
    206                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.SCANTO.pabloName(), BuiltinOperations.SCANTO.argCount())) {
    207                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.SCANTO.cPPCode(), carryCall, currentCarry);
     235                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTO.pabloName(), Builtins.SCANTO.argCount())) {
     236                                replaceFunctionInvocationNode(node,
     237                                                CarryQ.CarryQ_PACKAGE_NAME,
     238                                                builtins2Lang.getCode(Builtins.SCANTO),
     239                                                carryCall,
     240                                                currentCarry);
    208241                                this.currentCarry += 1;
    209242                        }                                                               
     
    217250        //            return c
    218251       
    219                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.SCANTOFIRST.pabloName(), BuiltinOperations.SCANTOFIRST.argCount())) {
    220                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.SCANTOFIRST.cPPCode(), carryCall, currentCarry);
     252                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTOFIRST.pabloName(), Builtins.SCANTOFIRST.argCount())) {
     253                                replaceFunctionInvocationNode(node,
     254                                                CarryQ.CarryQ_PACKAGE_NAME,
     255                                                builtins2Lang.getCode(Builtins.SCANTOFIRST),
     256                                                carryCall,
     257                                                currentCarry);
    221258                                this.currentCarry += 1;
    222259                        }                                                                               
     
    228265        //            self.current_adv_n += 1
    229266        //            return c
    230                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCE32.pabloName(), BuiltinOperations.ADVANCE32.argCount())) {
     267                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCE32.pabloName(), Builtins.ADVANCE32.argCount())) {
    231268                                //replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE32.cPPCode(), carryCall, currentAdvN);
    232269                                // TODO ==> verify advNCall
    233                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE32.cPPCode(), advNCall, currentAdvN);
     270                                replaceFunctionInvocationNode(node,
     271                                                CarryQ.CarryQ_PACKAGE_NAME,
     272                                                builtins2Lang.getCode(Builtins.ADVANCE32),
     273                                                advNCall,
     274                                                currentAdvN);
    234275                                this.currentAdvN += 1;
    235276                        }                       
     
    241282        //            self.current_adv_n += 1
    242283        //            return c         
    243                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCEN.pabloName(), BuiltinOperations.ADVANCEN.argCount())) {
     284                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCEN.pabloName(), Builtins.ADVANCEN.argCount())) {
    244285                                //replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCEN.cPPCode(), carryCall, currentAdvN);                                       
    245286                                // TODO ==> verify advNCall
    246                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE32.cPPCode(), advNCall, currentAdvN);         
     287                                replaceFunctionInvocationNode(node,
     288                                                CarryQ.CarryQ_PACKAGE_NAME,
     289                                                builtins2Lang.getCode(Builtins.ADVANCE32),
     290                                                advNCall,
     291                                                currentAdvN);           
    247292                                this.currentAdvN += 1;                 
    248293                        }                                       
     
    254299        //            else: return mkCall('simd_andc', [callnode.args[0], ast.Name('EOF_mask', ast.Load())])
    255300                       
    256                         else  if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ATEOF.pabloName(), BuiltinOperations.ATEOF.argCount())) {
     301                        else  if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ATEOF.pabloName(), Builtins.ATEOF.argCount())) {
    257302                                         
    258303                                if(!this.coMode) { // if not final block
     
    261306                                                args.add(arg);
    262307                                        }       
    263                                         args.add(Generators.makeIdentifierNode(Keywords.EOFMASK.cPPName(), node.getToken()));
     308                                        args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(Builtins.EOFMASK), node.getToken()));
    264309                                        replacementNode = Generators.makeFunctionInvocationNode(SIMD.ANDC.idisaName(), node.getToken(), args);
    265310                                       
     
    276321        //            else: return mkCall('simd_and', [callnode.args[0], ast.Name('EOF_mask', ast.Load())])
    277322
    278                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.INFILE.pabloName(), BuiltinOperations.INFILE.argCount())) {
     323                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.INFILE.pabloName(), Builtins.INFILE.argCount())) {
    279324                               
    280325                                if(!this.coMode) {  // if not final block
     
    284329                                                args.add(arg);
    285330                                        }
    286                                         args.add(Generators.makeIdentifierNode(Keywords.EOFMASK.cPPName(), node.getToken()));
     331                                        args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(Builtins.EOFMASK), node.getToken()));
    287332                                        replacementNode = Generators.makeFunctionInvocationNode(SIMD.AND.idisaName(), node.getToken(), args);
    288333                                       
Note: See TracChangeset for help on using the changeset viewer.