Changeset 2632


Ignore:
Timestamp:
Nov 12, 2012, 3:23:32 PM (6 years ago)
Author:
ksherdy
Message:

Checked in fixes for builtin operations.

Location:
proto/pablo
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • proto/pablo/input/test/pablo/all/all.pablo

    r2625 r2632  
    576576    marker.LAngle_scope = (LAngle_scope & (~ ctCDPI_mask));
    577577    marker.Ref_opener = (lex.RefStart & (~ ctCDPI_mask));
    578     marker.CD_closer = (CD_closer & (~ ctCDPI_mask));
    579 }
     578    marker.CD_closer &= (CD_closer &~ ctCDPI_mask);
     579}
  • proto/pablo/runConfigurations/pabloCompiler.launch

    r2625 r2632  
    99</listAttribute>
    1010<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="compiler.PabloCompiler"/>
    11 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="${workspace_loc}/pablo/input/test/pablo/all/all.pablo"/>
     11<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="${workspace_loc}/pablo/input/test/pablo/py2pablo/parabix2_pablo.pablo.exclude"/>
    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/PabloCompiler.java

    r2626 r2632  
    4545        public static void compile(String filename) throws FileNotFoundException {
    4646                               
    47                 LexicalController lexController     = LexicalController.make(filename);
    48                 ASTNode syntaxTree    = Parser.parse(lexController);
    49                
    50                 // Quick-and-dirty. Java Map. Proceed in a similar manner as the existing Python compiler.
    51                
     47                LexicalController lexController = LexicalController.make(filename);
     48                ASTNode syntaxTree = Parser.parse(lexController);
     49                               
    5250                StreamFunctionVisitor streamFunctionVisitor = new StreamFunctionVisitor(syntaxTree);
    5351                Map<String, ASTNode> streamFunctionMap = streamFunctionVisitor.makeStreamFunctionMap();
    5452               
    5553                for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {
     54
    5655                       
    57 //                  AdvanceCombiner advanceCombiner = new AdvanceCombiner(entry.getValue());
    58 //                  advanceCombiner.transform();
    59 //                  CarryCounter carryCounter = new CarryCounter(entry.getValue());
    60 //                  AdvanceNCounter advNCounter = new AdvanceNCounter(entry.getValue());
     56                    AdvanceCombiner advanceCombiner = new AdvanceCombiner(entry.getValue());
     57                    advanceCombiner.transform();
     58                   
     59                    CarryCounter carryCounter = new CarryCounter(entry.getValue());
     60                    AdvanceNCounter advNCounter = new AdvanceNCounter(entry.getValue());
    6161                       
    62 //                      System.out.println(entry.getKey());
    63 //                      System.out.println("Carry Count = " + carryCounter.count());
    64 //                      System.out.println("Adv n Count = " + advNCounter.count());
    65 //                      System.out.println();
     62                    //System.out.println();
     63                        //System.out.println(entry.getKey());
     64                        //System.out.println("Carry Count = " + carryCounter.count());
     65                        //System.out.println("Adv n Count = " + advNCounter.count());
     66                        //System.out.println();
     67                                               
     68                        Bitwise2IDISA bitwiseToIDISA = new Bitwise2IDISA(entry.getValue());
     69                        bitwiseToIDISA.transform();
    6670
    67 //                      Bitwise2IDISA bitwiseToIDISA = new Bitwise2IDISA(entry.getValue());
    68 //                      bitwiseToIDISA.transform();
     71                        AugmentedAssignment augmentedAssignment = new AugmentedAssignment(entry.getValue());
     72                        augmentedAssignment.transform();
    6973
    70 //                      AugmentedAssignment augmentedAssignment = new AugmentedAssignment(entry.getValue());
    71 //                      augmentedAssignment.transform();
     74                        CarryIntro carryIntro = new CarryIntro(entry.getValue());
     75                        carryIntro.transform(true, true);
    7276
    73 //                      CarryIntro carryIntro = new CarryIntro(entry.getValue());
    74 //                      carryIntro.transform(true, false);
     77                        Unparser cPPUnparser = new CPPUnparser(entry.getValue());
     78                        String code = cPPUnparser.getCode();
     79                        System.out.print(code);
     80               
    7581                }
    7682
    77                 AugmentedAssignment augmentedAssignment = new AugmentedAssignment(syntaxTree);
    78                 augmentedAssignment.transform();
    79  
    80                 Unparser cPPCodeGenerator = new CPPUnparser(syntaxTree);
    81                 String code = cPPCodeGenerator.getCode();
    82                 System.out.print(code);
    83 
    84                
    8583//              ASTNode decoratedTree = SemanticAnalyzer.analyze(syntaxTree);
    8684//              generateCodeIfNoErrors(filename, decoratedTree);
  • proto/pablo/src/compiler/ast/Accessors.java

    r2625 r2632  
    125125        // IfStatementNode helpers
    126126        ////////////////////////////////////////////////////////////////////////////   
    127         public static BlockStatementNode ifTest(IfStatementNode node) {
    128                 return (BlockStatementNode) node.child(0);
     127        public static ASTNode ifTest(IfStatementNode node) {
     128                return (ASTNode) node.child(0);
    129129        }
    130130       
     
    176176        public static ASTNode functionInvocationArgumentsListNode(FunctionInvocationNode node) {
    177177                return node.child(1);
     178        }
     179       
     180        public static int functionInvocationArgumentCount(FunctionInvocationNode node) {
     181                ASTNode argList = Accessors.functionInvocationArgumentsListNode(node);
     182                if (argList == null) {
     183                        return 0;
     184                }
     185                return argList.nChildren();
    178186        }
    179187       
  • proto/pablo/src/compiler/lang/pablo/builtins/BuiltinOperations.java

    r2598 r2632  
    99
    1010    ADVANCE(Carry.One, "Advance", 1, "BitBlock_advance_ci_co"),
    11     SCANTOFIRST(Carry.One, "ScanToFirst", 2, "BitBlock_scantofirst"),
     11    SCANTOFIRST(Carry.One, "ScanToFirst", 1, "BitBlock_scantofirst"),
    1212    SCANTHRU(Carry.One, "ScanThru", 2, "BitBlock_scanthru_ci_co"),
    1313    SCANTO(Carry.One, "ScanTo", 2, "BitBlock_scanto_ci_co"),
     
    2424    INFILE(Carry.None, "inFile", 1, "inFile");
    2525       
    26     public enum Carry{ One, N, None };   
     26    public enum Carry{One, N, None};   
    2727   
    2828    private final Carry type;
  • proto/pablo/src/compiler/lang/pablo/builtins/BuiltinsUtil.java

    r2621 r2632  
    99    public static String BUILTIN_PACKAGE_NAME = "pablo";
    1010       
    11     /** Returns true if the node represents a call to the
    12      *  given built-in 'Advance' function.
    13      * 
    14      * @param node                  node to be checked
    15      * @return                      whether the node is a call of the function
    16      */   
    1711    public static boolean isAdvance(ASTNode node) {
    18         if(!(node instanceof FunctionInvocationNode)) {
     12        if(node != null && !(node instanceof FunctionInvocationNode)) {
    1913            return false;
    2014        }
     
    2216        FunctionInvocationNode fNode = (FunctionInvocationNode)node;
    2317        ASTNode nameNode = Accessors.functionInvocationName(fNode);
     18        ASTNode argumentsListNode = (ASTNode)Accessors.functionInvocationArgumentsListNode(fNode);
    2419       
    25         if (isQualifiedName(nameNode, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCE.pabloName())) {
     20        if (isQualifiedName(nameNode, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCE.pabloName())
     21                && argumentsListNode.nChildren() == 1) {
    2622            return true;
    2723        }
     
    3026    }
    3127
     28    public static boolean isAdvanceN(ASTNode node) {
     29        if(node != null && !(node instanceof FunctionInvocationNode)) {
     30            return false;
     31        }
     32       
     33        FunctionInvocationNode fNode = (FunctionInvocationNode)node;
     34        ASTNode nameNode = Accessors.functionInvocationName(fNode);
     35        ASTNode argumentsListNode = (ASTNode)Accessors.functionInvocationArgumentsListNode(fNode);
     36       
     37        if (isQualifiedName(nameNode, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCE.pabloName())
     38                && argumentsListNode.nChildren() == 2) {       
     39                        return true;
     40        }
     41   
     42        return false;       
     43    }   
     44   
    3245    public static boolean isBuiltinOperations(ASTNode node) {
    3346       
     
    4356    public static boolean isCarryOne(ASTNode node) {
    4457       
    45                 for (BuiltinOperations carryOneOperation : BuiltinOperations.carryOneOperations()) {   
    46                 if (isQualifiedName(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, carryOneOperation.pabloName())) {
     58                for (BuiltinOperations carryOneOperation : BuiltinOperations.carryOneOperations()) {                           
     59                               
     60                        ASTNode identifier = Accessors.functionInvocationName((FunctionInvocationNode) node);
     61                        int argCount = Accessors.functionInvocationArgumentCount((FunctionInvocationNode)node);
     62                       
     63                        if (isQualifiedName(identifier, BuiltinsUtil.BUILTIN_PACKAGE_NAME, carryOneOperation.pabloName())
     64                                && argCount == carryOneOperation.argCount()) {
    4765                    return true;
    4866                }               
     
    5270   
    5371    public static boolean isCarryN(ASTNode node) {
    54      
    55                 for (BuiltinOperations carryNOperation : BuiltinOperations.carryNOperations()) {   
    56                 if (isQualifiedName(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, carryNOperation.pabloName())) {
    57                     return true;
     72               
     73                for (BuiltinOperations carryNOperation : BuiltinOperations.carryNOperations()) {
     74                        ASTNode identifier = Accessors.functionInvocationName((FunctionInvocationNode) node);
     75                        int argCount = Accessors.functionInvocationArgumentCount((FunctionInvocationNode) node);
     76                       
     77                if (isQualifiedName(identifier, BuiltinsUtil.BUILTIN_PACKAGE_NAME, carryNOperation.pabloName())
     78                        && argCount == carryNOperation.argCount()) {
     79                        return true;
    5880                }               
    5981                }
     
    144166            ASTNode pckage = node.child(0);
    145167            ASTNode member = node.child(1);
     168           
    146169            return   (Accessors.identifierLexeme(pckage) == packageName) &&
    147170                     (Accessors.identifierLexeme(member) == functionName);
  • proto/pablo/src/compiler/visitors/AdvanceCombiner.java

    r2621 r2632  
    5151                        int amount1 = advanceAmount(node);
    5252                        int amount2 = advanceAmount(child);
    53                        
    54                         /*
    55                         System.out.println("---");
    56                         System.out.println(node);
    57                         System.out.println("---");
    58                         System.out.println(child);
    59                         System.out.println("---");
    60                         System.out.println(streamBeingAdvanced);
    61                         System.out.println("---");
    62                         */
    63 
     53                                               
    6454                        translateAdvanceNode(node, child, amount1, amount2);
    6555                }               
    6656        }
    6757       
    68         ///////////////////////////////////////////////////////////////////
    69         // intelligence about integer constants
    70         ///////////////////////////////////////////////////////////////////
    71        
    72         // given that node is an IntegerConstantNode, what is its value?
    7358        private int valueOf(ASTNode node) {
    7459                assert node instanceof IntegerConstantNode;
     
    7762        }
    7863
    79                
    80         ///////////////////////////////////////////////////////////////////
    81         // intelligence about calls to advance()
    82         ///////////////////////////////////////////////////////////////////
    83 
    84         // given that node is an advance, what is the stream being advanced?
    8564        private ASTNode streamBeingAdvanced(FunctionInvocationNode node) {
    8665                assert BuiltinsUtil.isAdvance(node);
     
    10180                        return false;
    10281                }
    103                 ASTNode child = streamBeingAdvanced((FunctionInvocationNode) node);             
     82                ASTNode child = streamBeingAdvanced((FunctionInvocationNode) node);                            
    10483                return BuiltinsUtil.isAdvance(child);
    10584        }
  • proto/pablo/src/compiler/visitors/AdvanceNCounter.java

    r2621 r2632  
    11package compiler.visitors;
    22
     3import compiler.ast.Accessors;
    34import compiler.lang.pablo.builtins.BuiltinsUtil;
    45import ast.*;
     
    2930                        }
    3031                }
    31                
    3232        }
    3333}
  • proto/pablo/src/compiler/visitors/CarryCounter.java

    r2621 r2632  
    22
    33import ast.*;
     4import compiler.ast.Accessors;
    45import compiler.lang.pablo.builtins.BuiltinsUtil;
    56
     
    2627               
    2728                public void visitLeave(FunctionInvocationNode node) {
    28 
     29                       
    2930                        if(BuiltinsUtil.isCarryOne(node)) {
    3031                            carryCount += 1;
Note: See TracChangeset for help on using the changeset viewer.