Changeset 2598


Ignore:
Timestamp:
Nov 1, 2012, 2:14:25 PM (6 years ago)
Author:
ksherdy
Message:

Refactored compiler in preparation for code generation.

Location:
proto/pablo
Files:
1 added
4 deleted
7 edited
2 moved

Legend:

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

    r2575 r2598  
    99</listAttribute>
    1010<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="compiler.PabloCompilerTestHarness"/>
    11 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="${workspace_loc}/pablo/input/test/pablo/visitors"/>
     11<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="${workspace_loc}/home/ken/workspace/pablo/input/test/visitors"/>
    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/ast/Accessors.java

    r2464 r2598  
    22
    33import java.util.List;
    4 
    5 import org.w3c.dom.Node;
    64
    75import ast.ASTNode;
  • proto/pablo/src/compiler/codeGeneration/CarryQ.java

    r2445 r2598  
    1616                VALUEOF("cq[%d]",1);
    1717                               
    18                 private final String cName;
     18                private final String cPPName;
    1919                private final int argCount;
    2020               
    2121                Builtins(String cName, int argCount) {
    22                         this.cName = cName;
     22                        this.cPPName = cName;
    2323                        this.argCount = argCount;
    2424                }
    2525               
    26                 public String cName() {
    27                         return this.cName;
     26                public String cPPCode() {
     27                        return this.cPPName;
    2828                }
    2929               
  • proto/pablo/src/compiler/lang/pablo/builtins/BuiltinsUtil.java

    r2578 r2598  
    88import compiler.ast.Accessors;
    99
    10 public class Builtins {
     10public class BuiltinsUtil {
    1111   
    1212    public static String BUILTIN_PACKAGE_NAME = "pablo";
     
    2626        ASTNode nameNode = Accessors.functionInvocationName(fNode);
    2727       
    28         if (isQualifiedName(nameNode, Builtins.BUILTIN_PACKAGE_NAME, Carry1.ADVANCE.pabloName())) {
     28        if (isQualifiedName(nameNode, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCE.pabloName())) {
    2929            return true;
    3030        }
     
    3333    }
    3434
    35     public static boolean isCarry1(ASTNode node) {
     35    public static boolean isBuiltinOperations(ASTNode node) {
    3636       
    37                 for (Carry1 builtin : Carry1.values()) {   
    38                 if (isQualifiedName(node, Builtins.BUILTIN_PACKAGE_NAME, builtin.pabloName())) {
     37                for (BuiltinOperations builtin : BuiltinOperations.values()) {   
     38                if (isQualifiedName(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, builtin.pabloName())) {
    3939                    return true;
    4040                }               
     
    4242                return false;
    4343    }
     44     
     45   
     46    public static boolean isCarryOne(ASTNode node) {
    4447       
    45     public static boolean isCarryN(ASTNode node) {
    46    
    47                 for (CarryN builtin : CarryN.values()) {   
    48                 if (isQualifiedName(node, Builtins.BUILTIN_PACKAGE_NAME, builtin.pabloName())) {
     48                for (BuiltinOperations carryOneOperation : BuiltinOperations.carryOneOperations()) {   
     49                if (isQualifiedName(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, carryOneOperation.pabloName())) {
    4950                    return true;
    5051                }               
     
    5253                return false;
    5354    }
     55   
     56    public static boolean isCarryN(ASTNode node) {
     57     
     58                for (BuiltinOperations carryNOperation : BuiltinOperations.carryNOperations()) {   
     59                if (isQualifiedName(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, carryNOperation.pabloName())) {
     60                    return true;
     61                }               
     62                }
     63                return false;
     64    }
     65   
    5466       
    5567   
     
    6880        ASTNode nameNode = Accessors.functionInvocationName(fNode);
    6981
    70         for (Carry1 builtin : Carry1.values()) {
    71             if (isQualifiedName(nameNode, Builtins.BUILTIN_PACKAGE_NAME, builtin.pabloName())) {
     82        for (BuiltinOperations builtin : BuiltinOperations.values()) {
     83            if (isQualifiedName(nameNode, BuiltinsUtil.BUILTIN_PACKAGE_NAME, builtin.pabloName())) {
    7284                return true;
    7385            }
    7486        }
    75        
    76         for (CarryN builtin : CarryN.values()) {   
    77             if (isQualifiedName(nameNode, Builtins.BUILTIN_PACKAGE_NAME, builtin.pabloName())) {
    78                 return true;
    79             }                   
    80         }       
    81        
     87               
    8288        return false;
    8389    }
     
    9197    public static boolean isBuiltInCall(ASTNode node) {
    9298       
    93         for (Carry1 builtin : Carry1.values()) {   
    94             if (isCall(node, Builtins.BUILTIN_PACKAGE_NAME, builtin.pabloName(), builtin.argCount())) {
     99        for (BuiltinOperations builtin : BuiltinOperations.values()) {   
     100            if (isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, builtin.pabloName(), builtin.argCount())) {
    95101                return true;
    96102            }
    97103        }       
    98        
    99         for (CarryN builtin : CarryN.values()) {   
    100             if (isCall(node, Builtins.BUILTIN_PACKAGE_NAME, builtin.pabloName(), builtin.argCount())) {
    101                 return true;
    102             }                   
    103         }
    104        
     104
    105105        return false;
    106106    }
     
    141141     */
    142142    public static boolean isQualifiedName(ASTNode node, String packageName, String functionName) {
    143         if(node instanceof IdentifierNode) {
     143        if(node instanceof IdentifierNode) {           
    144144            return Accessors.identifierLexeme(node) == functionName;
    145145        }
  • proto/pablo/src/compiler/lang/pablo/builtins/Keywords.java

    r2578 r2598  
    11package compiler.lang.pablo.builtins;
    22
    3 public enum Constants {
     3public enum Keywords {
    44       
    55    EOFMASK("EOF_mask", "EOF_mask"); // BitBlock EOF_mask = simd_const_1(1);
    66   
    77        private final String pabloName;
    8         private final String cName;
     8        private final String cPPName;
    99       
    10         private Constants(String pabloName, String cName) {
     10        private Keywords(String pabloName, String cPPName) {
    1111                this.pabloName = pabloName;
    12                 this.cName = cName;
     12                this.cPPName = cPPName;
    1313        }
    1414       
    1515        public String pabloName() { return this.pabloName; }
    16         public String cName() { return this.cName; }
     16        public String cPPName() { return this.cPPName; }
    1717}
    1818
  • proto/pablo/src/compiler/visitors/AdvanceCombiner.java

    r2435 r2598  
    33
    44import compiler.ast.Generators;
    5 import compiler.lang.pablo.builtins.Builtins;
     5import compiler.lang.pablo.builtins.BuiltinsUtil;
    66
    77import tokens.*;
     
    7979        // given that node is an advance, what is the stream being advanced?
    8080        private ASTNode streamBeingAdvanced(FunctionInvocationNode node) {
    81                 assert Builtins.isAdvance(node);
     81                assert BuiltinsUtil.isAdvance(node);
    8282                return node.child(1);
    8383        }
    8484
    8585        private int advanceAmount(FunctionInvocationNode node) {
    86                 assert Builtins.isAdvance(node);
     86                assert BuiltinsUtil.isAdvance(node);
    8787                if(node.nChildren()==2) {
    8888                        return 1;
     
    9393       
    9494        private boolean isAdvanceOfAdvance(ASTNode node) {
    95                 if(!Builtins.isAdvance(node))
     95                if(!BuiltinsUtil.isAdvance(node))
    9696                        return false;
    9797       
    9898                ASTNode child = streamBeingAdvanced((FunctionInvocationNode) node);
    99                 return Builtins.isAdvance(child);
     99                return BuiltinsUtil.isAdvance(child);
    100100        }
    101101       
  • proto/pablo/src/compiler/visitors/AdvanceNCounter.java

    r2443 r2598  
    11package compiler.visitors;
    22
    3 import compiler.lang.pablo.builtins.Builtins;
     3import compiler.lang.pablo.builtins.BuiltinsUtil;
    44import ast.*;
    55
     
    2525
    2626                public void visitLeave(FunctionInvocationNode node) {
    27                         if(Builtins.isCarryN(node)) {
     27                        if(BuiltinsUtil.isCarryN(node)) {
    2828                            this.advNCount += 1;
    2929                        }
  • proto/pablo/src/compiler/visitors/CarryCounter.java

    r2443 r2598  
    22
    33import ast.*;
    4 import compiler.lang.pablo.builtins.Builtins;
     4import compiler.lang.pablo.builtins.BuiltinsUtil;
    55
    66public class CarryCounter {
     
    2727                public void visitLeave(FunctionInvocationNode node) {
    2828
    29                         if(Builtins.isBuiltInCall(node)) {
     29                        if(BuiltinsUtil.isCarryOne(node)) {
    3030                            carryCount += 1;
    3131                        }
  • proto/pablo/src/compiler/visitors/CarryIntro.java

    r2577 r2598  
    77import compiler.codeGeneration.CarryQ;
    88import compiler.lang.idisa.SIMD;
    9 import compiler.lang.pablo.builtins.Builtins;
    10 import compiler.lang.pablo.builtins.Carry1;
    11 import compiler.lang.pablo.builtins.CarryN;
    12 import compiler.lang.pablo.builtins.Constants;
    13 import compiler.lang.pablo.builtins.NoCarry;
     9import compiler.lang.pablo.builtins.BuiltinOperations;
     10import compiler.lang.pablo.builtins.BuiltinsUtil;
     11import compiler.lang.pablo.builtins.Keywords;
    1412
    1513import ast.*;
     
    4442                private final String ciSuffix = "_ci";
    4543                private final String coSuffix = "_co";
    46                 private String [] pendindCarryQName = {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.Builtins.GETCARRYIN.cName()};
    47                 private String [] pending64QName = {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.Builtins.GETPENDING64.cName()};
     44                private String [] pendindCarryQName = {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.Builtins.GETCARRYIN.cPPCode()};
     45                private String [] pending64QName = {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.Builtins.GETPENDING64.cPPCode()};
    4846               
    4947                private boolean ciMode;
     
    102100//              adv_n_args = [mkCall('simd<1>::constant<0>', []), ast.Num(self.current_adv_n)]
    103101                        if(ciMode) {
    104                                 carryCall = Generators.makeFunctionInvocationNode(new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.Builtins.GETCARRYIN.cName()}, node.getToken());
     102                                carryCall = Generators.makeFunctionInvocationNode(new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.Builtins.GETCARRYIN.cPPCode()}, node.getToken());
    105103                                carryCall.appendChild(currentCarry);
    106104                               
    107                                 advNCall = Generators.makeFunctionInvocationNode(new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.Builtins.GETPENDING64.cName()}, node.getToken());
     105                                advNCall = Generators.makeFunctionInvocationNode(new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.Builtins.GETPENDING64.cPPCode()}, node.getToken());
    108106                                advNCall.appendChild(currentAdvN);
    109107                               
     
    119117        //                    self.current_carry += 1
    120118        //                    return c                 
    121                         if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.ADVANCE.pabloName(), Carry1.ADVANCE.argCount())) {             
    122                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, Carry1.ADVANCE.cName(), carryCall, currentCarry);
     119                        if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCE.pabloName(), BuiltinOperations.ADVANCE.argCount())) {               
     120                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE.cPPCode(), carryCall, currentCarry);
    123121                                this.currentCarry += 1;
    124122                        }
     
    130128        //            self.current_carry += 1
    131129        //            return c         
    132                         else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.SCANTHRU.pabloName(), Carry1.SCANTHRU.argCount())) {                               
    133                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, Carry1.SCANTHRU.cName(), carryCall, currentCarry);
     130                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.SCANTHRU.pabloName(), BuiltinOperations.SCANTHRU.argCount())) {                         
     131                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.SCANTHRU.cPPCode(), carryCall, currentCarry);
    134132                                this.currentCarry += 1;
    135133                        }
     
    141139        //            self.current_carry += 1
    142140        //            return c         
    143                         else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.ADVANCETHENSCANTHRU.pabloName(), Carry1.ADVANCETHENSCANTHRU.argCount())) {
    144                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, Carry1.ADVANCETHENSCANTHRU.cName(), carryCall, currentCarry);
     141                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCETHENSCANTHRU.pabloName(), BuiltinOperations.ADVANCETHENSCANTHRU.argCount())) {
     142                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCETHENSCANTHRU.cPPCode(), carryCall, currentCarry);
    145143                                this.currentCarry += 1;
    146144                        }               
     
    152150        //            self.current_carry += 1
    153151        //            return c         
    154                         else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.SPANUPTO.pabloName(), Carry1.SPANUPTO.argCount())) {
    155                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, Carry1.SPANUPTO.cName(), carryCall, currentCarry);                             
     152                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.SPANUPTO.pabloName(), BuiltinOperations.SPANUPTO.argCount())) {
     153                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.SPANUPTO.cPPCode(), carryCall, currentCarry);                         
    156154                                this.currentCarry += 1;
    157155                        }               
     
    165163        //            self.current_carry += 1
    166164        //            return c
    167                         else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.ADVANCETHENSCANTO.pabloName(), Carry1.ADVANCETHENSCANTO.argCount())) {
    168                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, Carry1.ADVANCETHENSCANTO.cName(), carryCall, currentCarry);
     165                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCETHENSCANTO.pabloName(), BuiltinOperations.ADVANCETHENSCANTO.argCount())) {
     166                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCETHENSCANTO.cPPCode(), carryCall, currentCarry);
    169167                                this.currentCarry += 1;
    170168                        }               
     
    179177        //            return c
    180178       
    181                         else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.INCLUSIVESPAN.pabloName(), Carry1.INCLUSIVESPAN.argCount())) {
    182                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, Carry1.INCLUSIVESPAN.cName(), carryCall, currentCarry);
     179                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.INCLUSIVESPAN.pabloName(), BuiltinOperations.INCLUSIVESPAN.argCount())) {
     180                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.INCLUSIVESPAN.cPPCode(), carryCall, currentCarry);
    183181                                this.currentCarry += 1;
    184182                        }                               
     
    193191        //            return c
    194192       
    195                         else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.EXCLUSIVESPAN.pabloName(), Carry1.EXCLUSIVESPAN.argCount())) {
    196                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, Carry1.EXCLUSIVESPAN.cName(), carryCall, currentCarry);
     193                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.EXCLUSIVESPAN.pabloName(), BuiltinOperations.EXCLUSIVESPAN.argCount())) {
     194                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.EXCLUSIVESPAN.cPPCode(), carryCall, currentCarry);
    197195                                this.currentCarry += 1;
    198196                        }                                               
     
    209207        //            return c
    210208       
    211                         else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.SCANTO.pabloName(), Carry1.SCANTO.argCount())) {
    212                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, Carry1.SCANTO.cName(), carryCall, currentCarry);
     209                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.SCANTO.pabloName(), BuiltinOperations.SCANTO.argCount())) {
     210                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.SCANTO.cPPCode(), carryCall, currentCarry);
    213211                                this.currentCarry += 1;
    214212                        }                                                               
     
    222220        //            return c
    223221       
    224                         else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.SCANTOFIRST.pabloName(), Carry1.SCANTOFIRST.argCount())) {
    225                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, Carry1.SCANTOFIRST.cName(), carryCall, currentCarry);
     222                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.SCANTOFIRST.pabloName(), BuiltinOperations.SCANTOFIRST.argCount())) {
     223                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.SCANTOFIRST.cPPCode(), carryCall, currentCarry);
    226224                                this.currentCarry += 1;
    227225                        }                                                                               
     
    233231        //            self.current_adv_n += 1
    234232        //            return c
    235                         else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, CarryN.ADVANCE32.pabloName(), CarryN.ADVANCE32.argCount())) {
    236                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, CarryN.ADVANCE32.cName(), carryCall, currentAdvN);
     233                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCE32.pabloName(), BuiltinOperations.ADVANCE32.argCount())) {
     234                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE32.cPPCode(), carryCall, currentAdvN);
    237235                                this.currentAdvN += 1;
    238236                        }                       
     
    244242        //            self.current_adv_n += 1
    245243        //            return c         
    246                         else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, CarryN.ADVANCE.pabloName(), CarryN.ADVANCE.argCount())) {
    247                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, CarryN.ADVANCE.cName(), carryCall, currentAdvN);                                       
     244                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCEN.pabloName(), BuiltinOperations.ADVANCEN.argCount())) {
     245                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCEN.cPPCode(), carryCall, currentAdvN);                                 
    248246                                this.currentAdvN += 1;                 
    249247                        }                                       
     
    255253        //            else: return mkCall('simd_andc', [callnode.args[0], ast.Name('EOF_mask', ast.Load())])
    256254                       
    257                         else  if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, NoCarry.ATEOF.pabloName(), NoCarry.ATEOF.argCount())) {
     255                        else  if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ATEOF.pabloName(), BuiltinOperations.ATEOF.argCount())) {
    258256                                         
    259257                                if(!this.coMode) { // if not final block
     
    262260                                                replacementNode.appendChild(arg);
    263261                                        }                                                                       
    264                                         replacementNode.appendChild(Generators.makeIdentifierNode(Constants.EOFMASK.cName(), node.getToken()));
     262                                        replacementNode.appendChild(Generators.makeIdentifierNode(Keywords.EOFMASK.cPPName(), node.getToken()));
    265263                                } else {
    266264                                        replacementNode = Generators.makeFunctionInvocationNode(SIMD.CONSTANT.idisaConstantName(1, 0), node.getToken());                                       
     
    275273        //            else: return mkCall('simd_and', [callnode.args[0], ast.Name('EOF_mask', ast.Load())])
    276274
    277                         else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, NoCarry.INFILE.pabloName(), NoCarry.INFILE.argCount())) {
     275                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.INFILE.pabloName(), BuiltinOperations.INFILE.argCount())) {
    278276                               
    279277                                if(!this.coMode) {  // if not final block
     
    282280                                                replacementNode.appendChild(arg);
    283281                                        }                                                                       
    284                                         replacementNode.appendChild(Generators.makeIdentifierNode(Constants.EOFMASK.cName(), node.getToken()));
     282                                        replacementNode.appendChild(Generators.makeIdentifierNode(Keywords.EOFMASK.cPPName(), node.getToken()));
    285283                                } else {
    286284                                        replacementNode = Accessors.functionInvocationArg(node,0);
     
    299297//
    300298//                      else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, NoCarry.STREAMSCAN.pabloName(), NoCarry.STREAMSCAN.argCount())) {
    301 //                              replacementNode = Generators.makeFunctionInvocationNode(NoCarry.STREAMSCAN.cName(), node.getToken());
     299//                              replacementNode = Generators.makeFunctionInvocationNode(NoCarry.STREAMSCAN.cPPCode(), node.getToken());
    302300//                             
    303301//                              ASTNode arg0 = Generators.makeIdentifierNode("(ScanBlock *) &" + Accessors.identifierLexeme(Accessors.functionInvocationArg(node, 0)), node.getToken());
     
    346344                                ASTNode lhs = Accessors.ifTest(node);
    347345                                FunctionInvocationNode rhs = (FunctionInvocationNode) Generators.makeFunctionInvocationNode(
    348                                                                                                         new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.Builtins.CARRYTEST.cName()},
     346                                                                                                        new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.Builtins.CARRYTEST.cPPCode()},
    349347                                                                                                        node.getToken());
    350348                               
     
    363361                                // else part, append CarryDequeueEnqueue call
    364362                                FunctionInvocationNode carryDequeueEnqueue = (FunctionInvocationNode) Generators.makeFunctionInvocationNode(
    365                                                                                                                                 new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.Builtins.CARRYDEQUEUEENQUEUE.cName()},
     363                                                                                                                                new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.Builtins.CARRYDEQUEUEENQUEUE.cPPCode()},
    366364                                                                                                                                node.getToken());
    367365                               
Note: See TracChangeset for help on using the changeset viewer.