Changeset 2767 for proto


Ignore:
Timestamp:
Dec 11, 2012, 6:27:31 PM (7 years ago)
Author:
ksherdy
Message:

Implemented PabloS to PabloB XFormer.

Location:
proto/pablo
Files:
6 added
1 deleted
22 edited
2 copied
2 moved

Legend:

Unmodified
Added
Removed
  • proto/pablo/input/test/pabloS/funcDef/funcDef2.pablos

    r2766 r2767  
    1 function stream Function(stream a, stream b, stream c) {};
     1function stream FunXction(stream a, stream b, stream c) {};
  • proto/pablo/runConfigurations/pabloS.launch

    r2765 r2767  
    99</listAttribute>
    1010<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="applications.PabloS"/>
    11 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-i ${workspace_loc}/pablo/input/test/pablo/py2pablo/parabix2_pablo.pablo.exclude"/>
     11<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-i ${workspace_loc}/pablo/input/test/pabloS/py2pablo/parabix2_pablo.pablos.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/applications/ApplicationGenerator.java

    r2763 r2767  
    22
    33//import ast.StartSymbolNode;
    4 import pabloS.ast.ASTNode;
    5 import pabloS.tokens.Tokens;
    64
    7 import compiler.codeGenerator.CodeGenerator;
    85import compiler.lang.pabloS.*;
    96import compiler.lang.carryset.*;
     
    129import compiler.transformers.visitors.CPPXFormer;
    1310import compiler.transformers.visitors.CodeXFormer;
     11import compiler.transformers.visitors.PabloS2PabloBXFormer;
    1412
    1513public class ApplicationGenerator {
     
    2624       
    2725        public ApplicationGenerator(ApplicationConfig applicationConfiguration) {
    28                 Tokens.setPrintLevel(Tokens.Level.FULL);
     26                pabloS.tokens.Tokens.setPrintLevel(pabloS.tokens.Tokens.Level.FULL);
    2927                this.applicationConfig = applicationConfiguration;
    3028                OutputCodeFolder.setWarningMessage(generatedCodeWarning);
     
    5957               
    6058                // Transformation
    61                 ASTNode syntaxTree = SyntacticAnalyzer.parse(applicationConfig.inputFile);
     59                pabloS.ast.ASTNode syntaxTree = SyntacticAnalyzer.parse(applicationConfig.inputFile);
    6260               
    6361                // Generate Stream Type Decls   - Iterates over stream struct decl AST nodes
     
    6563                // Generate Stream Functions    - Iterates over stream function decl ASTs nodes
    6664               
     65                PabloS2PabloBXFormer xFormer = new PabloS2PabloBXFormer();
    6766               
    68                 System.out.print(unparser.getCode(syntaxTree));
     67                pabloB.ast.ASTNode node = xFormer.optXForm(syntaxTree, syntaxTree.deepCopy());
    6968                               
    70                
    7169                // Analyze and transform the AST
    72                 CodeGenerator semanticAnalyzer = new CodeGenerator(syntaxTree, builtins2Lang, carrySet2Lang);
     70                // CodeGenerator semanticAnalyzer = new CodeGenerator(syntaxTree, builtins2Lang, carrySet2Lang);
    7371                //ASTNode decorateTree = semanticAnalyzer.analyze();
    7472
  • proto/pablo/src/compiler/ast/pabloS/Accessors.java

    r2755 r2767  
    1 package compiler.pabloS.ast.helpers;
     1package compiler.ast.pabloS;
    22
    33import pabloS.ast.*;
     
    196196                return Accessors.name(node.child(1));
    197197        }
    198        
     198               
    199199        public static boolean hasParameters(FuncDefNode node) {
    200200                ASTNode child2 = node.child(2);
  • proto/pablo/src/compiler/ast/pabloS/Generators.java

    r2755 r2767  
    1 package compiler.pabloS.ast.helpers;
     1package compiler.ast.pabloS;
    22
    33import pabloS.ast.*;
     
    77
    88import compiler.lang.idisa.SIMD;
    9 import compiler.lang.pablo.Builtins;
    10 import compiler.lang.pablo.Builtins2Lang;
     9import compiler.lang.pabloS.Builtins;
     10import compiler.lang.pabloS.Builtins2Lang;
    1111
    1212import pabloS.lexicalAnalyzer.LexicalType;
     
    239239        }
    240240       
    241        
     241
    242242}
  • proto/pablo/src/compiler/codeGenerator/CodeGenerator.java

    r2749 r2767  
    22
    33import compiler.lang.carryset.CarrySet2Lang;
    4 import compiler.lang.pablo.Builtins2Lang;
     4import compiler.lang.pabloS.Builtins2Lang;
    55import compiler.transformers.visitors.*;
    66import pabloS.ast.ASTNode;
  • proto/pablo/src/compiler/codeGenerator/helpers/Generators.java

    r2755 r2767  
    44
    55import compiler.lang.carryset.CarrySet2Lang;
    6 import compiler.lang.pablo.Builtins2Lang;
    7 import compiler.pabloS.ast.helpers.Accessors;
     6import compiler.lang.pabloS.Builtins2Lang;
    87import compiler.transformers.visitors.*;
    98import compiler.transformers.visitors.helpers.CodeStore;
  • proto/pablo/src/compiler/lang/pabloS/BuiltinsUtil.java

    r2757 r2767  
    11package compiler.lang.pabloS;
    22
     3import compiler.ast.pabloS.Accessors;
     4
    35import pabloS.ast.*;
    4 import compiler.pabloS.ast.helpers.Accessors;
    56
    67public class BuiltinsUtil {
  • proto/pablo/src/compiler/transformers/visitors/AdvanceCombinerXFormer.java

    r2749 r2767  
    22
    33import pabloS.ast.*;
    4 import compiler.lang.pablo.BuiltinsUtil;
    5 import compiler.pabloS.ast.helpers.Accessors;
    6 import compiler.pabloS.ast.helpers.Generators;
     4import compiler.ast.pabloS.Accessors;
     5import compiler.ast.pabloS.Generators;
     6import compiler.lang.pabloS.BuiltinsUtil;
    77
    88import pabloS.tokens.*;
  • proto/pablo/src/compiler/transformers/visitors/AdvanceNCounterVisitor.java

    r2749 r2767  
    22
    33import pabloS.ast.*;
    4 import compiler.lang.pablo.BuiltinsUtil;
     4import compiler.lang.pabloS.BuiltinsUtil;
    55
    66public class AdvanceNCounterVisitor {
  • proto/pablo/src/compiler/transformers/visitors/AssertBitBlockAlignStmtsXFormer.java

    r2749 r2767  
    22
    33import pabloS.ast.*;
    4 import compiler.lang.pablo.Builtins;
    5 import compiler.lang.pablo.Builtins2Lang;
     4import compiler.ast.pabloS.Accessors;
     5import compiler.ast.pabloS.Generators;
     6import compiler.lang.pabloS.Builtins;
     7import compiler.lang.pabloS.Builtins2Lang;
    68import compiler.lang.carryset.CarrySet2Lang;
    7 import compiler.pabloS.ast.helpers.Accessors;
    8 import compiler.pabloS.ast.helpers.Generators;
    99
    1010public class AssertBitBlockAlignStmtsXFormer {
  • proto/pablo/src/compiler/transformers/visitors/AssertZeroXFormer.java

    r2749 r2767  
    22
    33import pabloS.ast.*;
    4 import compiler.lang.pablo.Builtins;
    5 import compiler.lang.pablo.Builtins2Lang;
    6 import compiler.lang.pablo.BuiltinsUtil;
     4import compiler.ast.pabloS.Accessors;
     5import compiler.ast.pabloS.Generators;
     6import compiler.lang.pabloS.Builtins;
     7import compiler.lang.pabloS.Builtins2Lang;
     8import compiler.lang.pabloS.BuiltinsUtil;
    79import compiler.lang.idisa.BitBlock;
    8 import compiler.pabloS.ast.helpers.Accessors;
    9 import compiler.pabloS.ast.helpers.Generators;
    1010
    1111public class AssertZeroXFormer {
  • proto/pablo/src/compiler/transformers/visitors/AugAssignXFormer.java

    r2749 r2767  
    44import java.util.Map;
    55
     6import compiler.ast.pabloS.Accessors;
     7import compiler.ast.pabloS.Generators;
     8
    69import pabloS.ast.*;
    710import pabloS.lexicalAnalyzer.Lextant;
    811import pabloS.tokens.*;
    912
    10 import compiler.pabloS.ast.helpers.Accessors;
    11 import compiler.pabloS.ast.helpers.Generators;
    1213
    1314public class AugAssignXFormer {
  • proto/pablo/src/compiler/transformers/visitors/Bitwise2IDISAXFormer.java

    r2749 r2767  
    55import pabloS.tokens.Token;
    66
     7import compiler.ast.pabloS.Accessors;
     8import compiler.ast.pabloS.Generators;
    79import compiler.lang.idisa.*;
    8 import compiler.pabloS.ast.helpers.Accessors;
    9 import compiler.pabloS.ast.helpers.Generators;
    1010
    1111public class Bitwise2IDISAXFormer {
  • proto/pablo/src/compiler/transformers/visitors/CPPXFormer.java

    r2749 r2767  
    77
    88//import compiler.codeGenerator.visitors.helpers.*;
     9import compiler.ast.pabloS.Accessors;
    910import compiler.lang.carryset.CarrySet2CPP;
    10 import compiler.lang.pablo.Builtins2CPP;
    11 import compiler.pabloS.ast.helpers.Accessors;
     11import compiler.lang.pabloS.Builtins2CPP;
    1212import compiler.transformers.visitors.helpers.CodeStore;
    1313import compiler.transformers.visitors.helpers.UnparserUtil;
  • proto/pablo/src/compiler/transformers/visitors/CarryCounterVisitor.java

    r2749 r2767  
    22
    33import pabloS.ast.*;
    4 import compiler.lang.pablo.BuiltinsUtil;
     4import compiler.lang.pabloS.BuiltinsUtil;
    55
    66public class CarryCounterVisitor {
  • proto/pablo/src/compiler/transformers/visitors/CarryIntroXFormer.java

    r2749 r2767  
    55import pabloS.lexicalAnalyzer.Lextant;
    66
     7import compiler.ast.pabloS.Accessors;
     8import compiler.ast.pabloS.Generators;
    79import compiler.lang.carryset.CarrySet;
    810import compiler.lang.carryset.CarrySet2Lang;
    9 import compiler.lang.pablo.BuiltinsUtil;
    10 import compiler.pabloS.ast.helpers.Accessors;
    11 import compiler.pabloS.ast.helpers.Generators;
     11import compiler.lang.pabloS.BuiltinsUtil;
    1212
    1313// TODO - Add while type to switch on/off carry in mode. Carry in is an internal to this visitor.
  • proto/pablo/src/compiler/transformers/visitors/DumpAssignStmtsXFormer.java

    r2749 r2767  
    22
    33import pabloS.ast.*;
    4 import compiler.lang.pablo.Builtins;
    5 import compiler.lang.pablo.Builtins2Lang;
    6 import compiler.pabloS.ast.helpers.Accessors;
    7 import compiler.pabloS.ast.helpers.Generators;
     4import compiler.ast.pabloS.Accessors;
     5import compiler.ast.pabloS.Generators;
     6import compiler.lang.pabloS.Builtins;
     7import compiler.lang.pabloS.Builtins2Lang;
    88
    99public class DumpAssignStmtsXFormer {
  • proto/pablo/src/compiler/transformers/visitors/Pablo2CarryXFormer.java

    r2749 r2767  
    55
    66import pabloS.ast.*;
     7import compiler.ast.pabloS.Accessors;
     8import compiler.ast.pabloS.Generators;
    79import compiler.lang.carryset.CarrySet;
    810import compiler.lang.carryset.CarrySet2Lang;
    911import compiler.lang.idisa.SIMD;
    10 import compiler.lang.pablo.*;
    11 import compiler.pabloS.ast.helpers.Accessors;
    12 import compiler.pabloS.ast.helpers.Generators;
     12import compiler.lang.pabloS.*;
    1313
    1414//TODO - Add while type to switch on/off carry in mode. Carry in is an internal to this visitor.
  • proto/pablo/src/compiler/transformers/visitors/PabloS2PabloBXFormer.java

    r2755 r2767  
    11package compiler.transformers.visitors;
    22
    3 import java.util.ArrayList;
     3import java.util.LinkedHashMap;
    44import java.util.List;
    5 
    6 import pabloS.ast.*;
    7 import compiler.lang.carryset.CarrySet;
    8 import compiler.lang.carryset.CarrySet2Lang;
    9 import compiler.lang.idisa.SIMD;
    10 import compiler.lang.pablo.*;
    11 import compiler.pabloS.ast.helpers.Accessors;
    12 import compiler.pabloS.ast.helpers.Generators;
    13 import compiler.syntacticAnalysis.SyntacticAnalysisFailedException;
    14 
    15 
    16 
    17 public class Pablo2PabloBlockXFormer {
    18 
    19         public static Boolean ASSERT_INTERMEDIATE_LANG_XFORM = false;
    20         public static String ASSERT_INTERMEDIATE_LANG_XFORM_MSG = "Pablo to Pablo intermediate language transformation is not supported.";
    21        
    22         private ASTNode ASTTree = null;         
    23         private ASTNode optASTTree = null; // optimized ASTTree // final block         
    24        
    25     public Pablo2PabloBlockXFormer() {
    26         this.ASTTree = null;
    27         this.optASTTree = null;
     5import java.util.Map;
     6
     7import compiler.ast.pabloB.Generators;
     8import compiler.ast.pabloS.Accessors;
     9import pabloS.ast.ASTVisitor.Default;
     10
     11public class PabloS2PabloBXFormer {
     12
     13        private static final String DO_BLOCK            = "do_block";
     14        private static final String DO_OPT_BLOCK        = "do_final_block";
     15       
     16        public static Boolean PABLO2PABLOB_XFORM_SUPPORT = false;
     17        public static String PABLO2PABLOB_XFORM_SUPPORT_MSG = "PabloS to PabloB node transformation not supported.";
     18       
     19        private pabloS.ast.ASTNode sASTTree;   
     20        private pabloS.ast.ASTNode sOptASTTree;                 
     21       
     22    public PabloS2PabloBXFormer() {
     23        this.sASTTree = null;
     24        this.sOptASTTree = null;
    2825    }
    2926
    30     public ASTNode XForm(ProgramNode root) {
    31                 this.ASTTree = root;
    32                 this.optASTTree = root;
    33 
    34                 ASTNode copy = ASTTree.deepCopy();     
    35                 XFormer xFormer = new XFormer();
    36                 copy.accept(xFormer);
    37                 return copy;
     27    /*
     28    public pabloB.ast.ASTNode XForm(pabloS.ast.ASTNode root) {
     29        pabloB.ast.ASTNode node = null;
     30                return node;
    3831    }
     32    */
    3933   
    40     public ASTNode optXForm(ProgramNode root, ProgramNode optRoot) {
    41                 this.ASTTree = root;
    42                 this.optASTTree = optRoot;
    43        
    44                 ASTNode copy = ASTTree.deepCopy();     
    45                 XFormer xFormer = new XFormer();
    46                 copy.accept(xFormer);
    47                 return copy;
    48     }                   
    49        
    50         private class XFormer extends VoidVisitor.Default {
    51                
    52                 public XFormer() {}                             
    53                
     34    public pabloB.ast.ASTNode optXForm(pabloS.ast.ASTNode sASTTree, pabloS.ast.ASTNode sOptASTTree) {
     35               
     36        this.sASTTree = sASTTree;
     37                this.sOptASTTree = sOptASTTree;
     38       
     39                // xForm PabloS to PabloB
     40                pabloB.ast.ASTNode bASTTree = this.sASTTree.accept(new pabloBASTBuilder());
     41                pabloB.ast.ASTNode bOptASTTree = this.sOptASTTree.accept(new pabloBASTBuilder());
     42                 
     43                Map<String, pabloB.ast.FuncDefNode> map = funcDefMapBuilder(bASTTree);
     44                Map<String, pabloB.ast.FuncDefNode> optMap = funcDefMapBuilder(bOptASTTree);
     45               
     46                for (Map.Entry<String, pabloB.ast.FuncDefNode> entry : map.entrySet())
     47                {       
     48                        pabloB.ast.FuncDefNode funcDefNode = entry.getValue();
     49                        pabloB.ast.FuncDefNode optFuncDefNode = optMap.get(entry.getKey());
     50               
     51                        pabloB.tokens.Token locationToken = funcDefNode.getToken();
     52                       
     53                        pabloB.ast.IdentifierNode doBlockIdentifier = Generators.makeIdentifierNode(DO_BLOCK, locationToken);
     54                        funcDefNode.replaceChild(funcDefNode.child(1), doBlockIdentifier);
     55
     56                        pabloB.ast.IdentifierNode doOptBlockIdentifier = Generators.makeIdentifierNode(DO_OPT_BLOCK, locationToken);
     57                        optFuncDefNode.replaceChild(optFuncDefNode.child(1), doOptBlockIdentifier);
     58                       
     59                        // make kernel node
     60                        pabloB.ast.KernelDefNode kernelDefNode =
     61                                        Generators.makeKernelDef(entry.getKey(), funcDefNode, optFuncDefNode, locationToken);
     62                       
     63                        // slice kernel node into PabloB tree
     64                        funcDefNode.updateSelf(kernelDefNode);
     65                                       
     66                }
     67               
     68                return bASTTree;
     69    }
     70         
     71   
     72   
     73   
     74        private class pabloBASTBuilder extends Default<pabloB.ast.ASTNode> {
     75                       
     76                public pabloB.ast.ASTNode visitLeave(pabloS.ast.AssignNode node, List<pabloB.ast.ASTNode> childResults) {
     77                        pabloB.ast.ASTNode bNode = new pabloB.ast.AssignNode(Generators.makePabloBToken(node.getToken()));
     78                        appendChildResults(bNode, childResults);
     79                        return bNode;
     80                }
     81
     82                /*
     83                public void visitEnter(AssignOperatorNode node) {
     84                        defaultVisitEnter(node);
     85                }
     86                */
     87               
     88                public pabloB.ast.ASTNode visitLeave(pabloS.ast.AssignOperatorNode node, List<pabloB.ast.ASTNode> childResults) {
     89                        pabloB.ast.ASTNode bNode = new pabloB.ast.AssignOperatorNode(Generators.makePabloBToken(node.getToken()));
     90                        appendChildResults(bNode, childResults);
     91                        return bNode;
     92                }
     93
     94                /*
     95                public void visitEnter(BinaryOperatorNode node) {
     96                        defaultVisitEnter(node);
     97                }
     98                */
     99               
     100                public pabloB.ast.ASTNode visitLeave(pabloS.ast.BinaryOperatorNode node, List<pabloB.ast.ASTNode> childResults) {
     101                        pabloB.ast.ASTNode bNode = new pabloB.ast.BinaryOperatorNode(Generators.makePabloBToken(node.getToken()));                     
     102                        appendChildResults(bNode, childResults);
     103                        return bNode;
     104                }
     105
     106                /*
     107                public void visitEnter(BlockStmtNode node) {
     108                        defaultVisitEnter(node);
     109                }
     110                */
     111               
     112                public pabloB.ast.ASTNode visitLeave(pabloS.ast.BlockStmtNode node, List<pabloB.ast.ASTNode> childResults) {
     113                        pabloB.ast.ASTNode bNode = new pabloB.ast.BlockStmtNode(Generators.makePabloBToken(node.getToken()));
     114                        appendChildResults(bNode, childResults);
     115                        return bNode;
     116                }
     117
     118                /*
     119                public void visitEnter(CompoundIdentifierNode node) {
     120                        defaultVisitEnter(node);
     121                }
     122                */
     123               
     124                public pabloB.ast.ASTNode visitLeave(pabloS.ast.CompoundIdentifierNode node, List<pabloB.ast.ASTNode> childResults) {
     125                        pabloB.ast.ASTNode bNode = new pabloB.ast.CompoundIdentifierNode(Generators.makePabloBToken(node.getToken()));
     126                        appendChildResults(bNode, childResults);
     127                        return bNode;
     128                }
     129
     130                /*
     131                public void visitEnter(EpsilonNode node) {
     132                        defaultVisitEnter(node);
     133                }
     134                */
     135               
     136                public pabloB.ast.ASTNode visitLeave(pabloS.ast.EpsilonNode node, List<pabloB.ast.ASTNode> childResults) {
     137                        pabloB.ast.ASTNode bNode = new pabloB.ast.EpsilonNode(Generators.makePabloBToken(node.getToken()));
     138                        appendChildResults(bNode, childResults);
     139                        return bNode;
     140                }
     141
     142                /*
     143                public void visitEnter(ErrorNode node) {
     144                        defaultVisitEnter(node);
     145                }
     146                */
     147               
     148                public pabloB.ast.ASTNode visitLeave(pabloS.ast.ErrorNode node, List<pabloB.ast.ASTNode> childResults) {
     149                        pabloB.ast.ASTNode bNode = new pabloB.ast.ErrorNode(Generators.makePabloBToken(node.getToken()));
     150                        appendChildResults(bNode, childResults);
     151                        return bNode;
     152                }
     153
     154                /*
     155                public void visitEnter(FieldWidthNode node) {
     156                        defaultVisitEnter(node);
     157                }
     158                */
     159               
     160                public pabloB.ast.ASTNode visitLeave(pabloS.ast.FieldWidthNode node, List<pabloB.ast.ASTNode> childResults) {
     161                        pabloB.ast.ASTNode bNode = new pabloB.ast.FieldWidthNode(Generators.makePabloBToken(node.getToken()));
     162                        appendChildResults(bNode, childResults);
     163                        return bNode;
     164                }
     165
     166                /*
     167                public void visitEnter(FuncCallArgListNode node) {
     168                        defaultVisitEnter(node);
     169                }
     170                */
     171               
     172                public pabloB.ast.ASTNode visitLeave(pabloS.ast.FuncCallArgListNode node, List<pabloB.ast.ASTNode> childResults) {
     173                        pabloB.ast.ASTNode bNode = new pabloB.ast.FuncCallArgListNode(Generators.makePabloBToken(node.getToken()));
     174                        appendChildResults(bNode, childResults);
     175                        return bNode;
     176                }
     177
     178                /*
     179                public void visitEnter(FuncCallNode node) {
     180                        defaultVisitEnter(node);
     181                }
     182                */
     183               
     184                public pabloB.ast.ASTNode visitLeave(pabloS.ast.FuncCallNode node, List<pabloB.ast.ASTNode> childResults) {
     185                        pabloB.ast.ASTNode bNode = new pabloB.ast.FuncCallNode(Generators.makePabloBToken(node.getToken()));
     186                        appendChildResults(bNode, childResults);
     187                        return bNode;
     188                }
     189
     190                /*
     191                public void visitEnter(FuncCallOrAssignStmtNode node) {
     192                        defaultVisitEnter(node);
     193                }
     194                */
     195               
     196                public pabloB.ast.ASTNode visitLeave(pabloS.ast.FuncCallOrAssignStmtNode node, List<pabloB.ast.ASTNode> childResults) {
     197                        pabloB.ast.ASTNode bNode = new pabloB.ast.FuncCallOrAssignStmtNode(Generators.makePabloBToken(node.getToken()));
     198                        appendChildResults(bNode, childResults);
     199                        return bNode;
     200                }
     201
     202                /*
     203                public void visitEnter(FuncDefNode node) {
     204                        defaultVisitEnter(node);
     205                }
     206                */
     207                       
     208                public pabloB.ast.ASTNode visitLeave(pabloS.ast.FuncDefNode node, List<pabloB.ast.ASTNode> childResults) {
     209                       
     210
     211
     212                        pabloB.ast.ASTNode bNode = new pabloB.ast.FuncDefNode(Generators.makePabloBToken(node.getToken()));
     213                        appendChildResults(bNode, childResults);
     214                       
     215                        return bNode;
     216                }
     217
     218                /*
     219                public void visitEnter(IdentifierNode node) {
     220                        defaultVisitEnter(node);
     221                }
     222                */
     223               
     224                public pabloB.ast.ASTNode visitLeave(pabloS.ast.IdentifierNode node, List<pabloB.ast.ASTNode> childResults) {
     225                        pabloB.ast.ASTNode bNode = new pabloB.ast.IdentifierNode(Generators.makePabloBToken(node.getToken()));
     226                        appendChildResults(bNode, childResults);
     227                        return bNode;
     228                }
     229
     230                /*
     231                public void visitEnter(IfStmtNode node) {
     232                        defaultVisitEnter(node);
     233                }
     234                */
     235               
     236                public pabloB.ast.ASTNode visitLeave(pabloS.ast.IfStmtNode node, List<pabloB.ast.ASTNode> childResults) {
     237                        pabloB.ast.ASTNode bNode = new pabloB.ast.IfStmtNode(Generators.makePabloBToken(node.getToken()));
     238                        appendChildResults(bNode, childResults);
     239                        return bNode;
     240                }
     241
     242                /*
     243                public void visitEnter(IntegerConstantNode node) {
     244                        defaultVisitEnter(node);
     245                }
     246                */
     247               
     248                public pabloB.ast.ASTNode visitLeave(pabloS.ast.IntegerConstantNode node, List<pabloB.ast.ASTNode> childResults) {
     249                        pabloB.ast.ASTNode bNode = new pabloB.ast.IntegerConstantNode(Generators.makePabloBToken(node.getToken()));
     250                        int value = new Integer(bNode.getToken().getLexeme());
     251                        ((pabloB.ast.IntegerConstantNode)bNode).setValue(value); // set integer constant value
     252                        appendChildResults(bNode, childResults);
     253                        return bNode;
     254                }
     255
     256                /*
     257                public void visitEnter(LocalVarDeclNode node) {
     258                        defaultVisitEnter(node);
     259                }
     260                */
     261               
     262                public pabloB.ast.ASTNode visitLeave(pabloS.ast.LocalVarDeclNode node, List<pabloB.ast.ASTNode> childResults) {
     263                        pabloB.ast.ASTNode bNode = new pabloB.ast.LocalVarDeclNode(Generators.makePabloBToken(node.getToken()));
     264                        appendChildResults(bNode, childResults);
     265                        return bNode;
     266                }
     267               
     268                /*
     269                public void visitEnter(ParameterListNode node) {
     270                        defaultVisitEnter(node);
     271                }
     272                */
     273               
     274                public pabloB.ast.ASTNode visitLeave(pabloS.ast.ParameterListNode node, List<pabloB.ast.ASTNode> childResults) {
     275                        pabloB.ast.ASTNode bNode = new pabloB.ast.ParameterListNode(Generators.makePabloBToken(node.getToken()));                       
     276                        appendChildResults(bNode, childResults);
     277                        return bNode;
     278                }
     279
     280                /*
     281                public void visitEnter(ParameterNode node) {
     282                        defaultVisitEnter(node);
     283                }
     284                */
     285               
     286                public pabloB.ast.ASTNode visitLeave(pabloS.ast.ParameterNode node, List<pabloB.ast.ASTNode> childResults) {
     287                        pabloB.ast.ASTNode bNode = new pabloB.ast.ParameterNode(Generators.makePabloBToken(node.getToken()));
     288                        appendChildResults(bNode, childResults);
     289                        return bNode;
     290                }
     291               
     292                /*
     293                public void visitEnter(ProgramNode node) {
     294                        defaultVisitEnter(node);
     295                }
     296                */
     297               
     298                public pabloB.ast.ASTNode visitLeave(pabloS.ast.ProgramNode node, List<pabloB.ast.ASTNode> childResults) {
     299                        pabloB.ast.ProgramNode bNode = new pabloB.ast.ProgramNode(Generators.makePabloBToken(node.getToken()));
     300                        appendChildResults(bNode, childResults);
     301                        return bNode;
     302                }
     303
     304                /*
     305                public void visitEnter(ReturnStmtNode node) {
     306                        defaultVisitEnter(node);
     307                }
     308                */
     309               
     310                public pabloB.ast.ASTNode visitLeave(pabloS.ast.ReturnStmtNode node, List<pabloB.ast.ASTNode> childResults) {
     311                        pabloB.ast.ASTNode bNode = new pabloB.ast.ReturnStmtNode(Generators.makePabloBToken(node.getToken()));
     312                        appendChildResults(bNode, childResults);
     313                        return bNode;
     314                }
     315
     316                /*
     317                public void visitEnter(StreamTypeNode node) {
     318                        defaultVisitEnter(node);
     319                }
     320                */
     321               
     322                public pabloB.ast.ASTNode visitLeave(pabloS.ast.StreamTypeNode node, List<pabloB.ast.ASTNode> childResults) {
     323                        pabloB.ast.ASTNode bNode = new pabloB.ast.StreamTypeNode(Generators.makePabloBToken(node.getToken()));
     324                        appendChildResults(bNode, childResults);
     325                        return bNode;
     326                }
     327
     328                /*
     329                public void visitEnter(StringConstantNode node) {
     330                        defaultVisitEnter(node);
     331                }
     332                */
     333               
     334                public pabloB.ast.ASTNode visitLeave(pabloS.ast.StringConstantNode node, List<pabloB.ast.ASTNode> childResults) {
     335                        pabloB.ast.ASTNode bNode = new pabloB.ast.StringConstantNode(Generators.makePabloBToken(node.getToken()));
     336                        appendChildResults(bNode, childResults);
     337                        return bNode;
     338                }
     339
     340                /*
     341                public void visitEnter(StructMemberNode node) {
     342                        defaultVisitEnter(node);
     343                }
     344                */
     345               
     346                public pabloB.ast.ASTNode visitLeave(pabloS.ast.StructMemberNode node, List<pabloB.ast.ASTNode> childResults) {
     347                        pabloB.ast.ASTNode bNode = new pabloB.ast.StructMemberNode(Generators.makePabloBToken(node.getToken()));
     348                        appendChildResults(bNode, childResults);
     349                        return bNode;
     350                }
     351
     352                /*
     353                public void visitEnter(StructTypeBodyNode node) {
     354                        defaultVisitEnter(node);
     355                }
     356                */
     357               
     358                public pabloB.ast.ASTNode visitLeave(pabloS.ast.StructTypeBodyNode node, List<pabloB.ast.ASTNode> childResults) {
     359                        pabloB.ast.ASTNode bNode = new pabloB.ast.StructTypeBodyNode(Generators.makePabloBToken(node.getToken()));
     360                        appendChildResults(bNode, childResults);
     361                        return bNode;
     362                }
     363
     364                /*
     365                public void visitEnter(StructTypeNode node) {
     366                        defaultVisitEnter(node);
     367                }
     368                */
     369               
     370                public pabloB.ast.ASTNode visitLeave(pabloS.ast.StructTypeNode node, List<pabloB.ast.ASTNode> childResults) {
     371                        pabloB.ast.ASTNode bNode = new pabloB.ast.StructTypeNode(Generators.makePabloBToken(node.getToken()));
     372                        appendChildResults(bNode, childResults);
     373                        return bNode;
     374                }
     375
     376                /*
     377                public void visitEnter(pabloB.ast.ASTNodeypeDeclNode node) {
     378                        defaultVisitEnter(node);
     379                }
     380                */
     381               
     382                public pabloB.ast.ASTNode visitLeave(pabloS.ast.TypeDeclNode node, List<pabloB.ast.ASTNode> childResults) {
     383                        pabloB.ast.ASTNode bNode = new pabloB.ast.TypeDeclNode(Generators.makePabloBToken(node.getToken()));
     384                        appendChildResults(bNode, childResults);
     385                        return bNode;
     386                }
     387
     388                /*
    54389                public void visitEnter(TypeDefNode node) {
    55                        
    56                         assert ASSERT_INTERMEDIATE_LANG_XFORM : node.getClass() + ": " + ASSERT_INTERMEDIATE_LANG_XFORM_MSG;
    57                
    58                         // TODO - transformation to explicit types
    59                        
    60                 }       
    61                
    62                 public void visitLeave(TypeDefNode node) {
    63                        
    64                        
    65                        
    66                        
    67                        
    68                 }
    69 
     390                        defaultVisitEnter(node);
     391                }
     392                */
     393               
     394                public pabloB.ast.ASTNode visitLeave(pabloS.ast.TypeDefNode node, List<pabloB.ast.ASTNode> childResults) {
     395                        throw new RuntimeException(node.getClass().toString() + ": node class not supported.");
     396                }
     397
     398                /*
     399                public void visitEnter(UnaryOperatorNode node) {
     400                        defaultVisitEnter(node);
     401                }
     402                */
     403               
     404                public pabloB.ast.ASTNode visitLeave(pabloS.ast.UnaryOperatorNode node, List<pabloB.ast.ASTNode> childResults) {
     405                        pabloB.ast.ASTNode bNode = new pabloB.ast.UnaryOperatorNode(Generators.makePabloBToken(node.getToken()));
     406                        appendChildResults(bNode, childResults);
     407                        return bNode;
     408                }
     409
     410                /*
     411                public void visitEnter(VoidNode node) {
     412                        defaultVisitEnter(node);
     413                }
     414                */
     415               
     416                public pabloB.ast.ASTNode visitLeave(pabloS.ast.VoidNode node, List<pabloB.ast.ASTNode> childResults) {
     417                        pabloB.ast.ASTNode bNode = new pabloB.ast.VoidNode(Generators.makePabloBToken(node.getToken()));
     418                        appendChildResults(bNode, childResults);
     419                        return bNode;
     420                }
     421
     422                /*
     423                public void visitEnter(WhileStmtNode node) {
     424                        defaultVisitEnter(node);
     425                }
     426                */
     427               
     428                public pabloB.ast.ASTNode visitLeave(pabloS.ast.WhileStmtNode node, List<pabloB.ast.ASTNode> childResults) {
     429                        pabloB.ast.ASTNode bNode = new pabloB.ast.WhileStmtNode(Generators.makePabloBToken(node.getToken()));
     430                        appendChildResults(bNode, childResults);
     431                        return bNode;
     432                }
     433               
    70434        }       
    71        
     435
     436/*     
     437        private  class String2FuncDefNodeMapBuilder extends VoidVisitor.Default {
     438       
     439                private pabloB.ast.ASTNode ASTTree;
     440
     441               
     442                public Map<String, ASTNode> streamFuncMap() {
     443                        return streamFuncMap;
     444                }
     445                               
     446                public void visitLeave(FuncDefNode node) {
     447                                                       
     448                        String name = Accessors.funcName(node);
     449                        name = Generators.capitalize(name);
     450                        IdentifierToken nameToken = IdentifierToken.make(LexicalType.IDENTIFIER,
     451                                                                                node.getToken().getLocation(),
     452                                                                                name);
     453                       
     454                        Accessors.funcIdentifier(node).setToken(nameToken);
     455                        streamFuncMap.put(name, node);                                 
     456                       
     457                }               
     458        }       
     459*/
     460
     461        private static Map<String, pabloB.ast.FuncDefNode> funcDefMapBuilder(pabloB.ast.ASTNode node) {
     462
     463                if(node instanceof pabloB.ast.FuncDefNode) {
     464                       
     465                        LinkedHashMap<String, pabloB.ast.FuncDefNode> linkedHashMap = new LinkedHashMap<String, pabloB.ast.FuncDefNode>();
     466                       
     467                        String key = compiler.ast.pabloB.Accessors.funcName((pabloB.ast.FuncDefNode)node);
     468                        pabloB.ast.FuncDefNode value = (pabloB.ast.FuncDefNode)node;
     469                        linkedHashMap.put(key, value);
     470                        return linkedHashMap;
     471                }
     472               
     473                LinkedHashMap<String, pabloB.ast.FuncDefNode> linkedHashMap = new LinkedHashMap<String, pabloB.ast.FuncDefNode>();
     474               
     475                for(pabloB.ast.ASTNode child : node.getChildren()) {
     476                        linkedHashMap.putAll(funcDefMapBuilder(child));
     477                }
     478               
     479                return linkedHashMap;   
     480        }
     481       
     482       
     483        private static pabloS.ast.FuncDefNode recursiveSearch(pabloS.ast.ASTNode node, String target) {
     484       
     485                if(node instanceof pabloS.ast.ASTNode) {
     486                        if(Accessors.funcName((pabloS.ast.FuncDefNode)node).equals(target)) {
     487                                return (pabloS.ast.FuncDefNode)node;
     488                        }
     489                }
     490               
     491                pabloS.ast.FuncDefNode result = null;
     492               
     493                for(pabloS.ast.ASTNode child : node.getChildren()) {
     494                        result = recursiveSearch(child, target);
     495                        if (result != null) {
     496                                break;
     497                        }
     498                }
     499               
     500                return result; 
     501        }
     502       
     503        private static void appendChildResults(pabloB.ast.ASTNode bNode, List<pabloB.ast.ASTNode> childResults) {
     504                for(pabloB.ast.ASTNode child : childResults) {
     505                        bNode.appendChild(child);
     506                }
     507        }
    72508}
  • proto/pablo/src/compiler/transformers/visitors/StreamFuncVisitor.java

    r2749 r2767  
    33import java.util.*;
    44
     5import compiler.ast.pabloS.Accessors;
     6import compiler.ast.pabloS.Generators;
     7
    58import pabloS.ast.*;
    69import pabloS.lexicalAnalyzer.LexicalType;
    710import pabloS.tokens.IdentifierToken;
    8 import compiler.pabloS.ast.helpers.Accessors;
    9 import compiler.pabloS.ast.helpers.Generators;
    1011
    1112
     
    5758                        streamFuncMap.put(name, node);                                 
    5859                       
    59                 }
    60                
     60                }               
    6161        }
    6262}
  • proto/pablo/src/pabloB/tokens/LextantToken.java

    r2749 r2767  
    3838                return new LextantToken(location, lexeme, lextant);
    3939        }
     40       
    4041}
  • proto/pablo/src/pabloS/ast/ASTNode.java

    r2749 r2767  
    112112        public void replaceChild(ASTNode node, ASTNode replacement) {
    113113                int index = children.indexOf(node);
     114               
     115               
     116               
    114117                replaceChild(index, replacement);
    115118        }
  • proto/pablo/src/test/pabloS/PabloSTestHarness.java

    r2755 r2767  
    2222import compiler.lang.carryset.CarrySet2Lang;
    2323import compiler.lang.idisa.*;
    24 import compiler.lang.pablo.Builtins2CPP;
    25 import compiler.lang.pablo.Builtins2Lang;
    26 import compiler.ast.visitors.*;
     24import compiler.lang.pabloS.Builtins2CPP;
     25import compiler.lang.pabloS.Builtins2Lang;
    2726import compiler.test.*;
    2827import compiler.transformers.visitors.AdvanceCombinerXFormer;
     
    3635public class PabloSTestHarness {
    3736
     37        private static final String PABLOSEXT = ".pablos";
    3838        protected static final int EXIT_CODE_FOR_ERROR = 1;
    3939        protected static String outputDirectory = "output/";
     
    8484                                ArrayList<File> files = new ArrayList<File>();
    8585                                dir = testBase.getAbsolutePath() + File.separator + test.directory();
    86                                 files = matchFiles(new File (dir), ".pablo");
     86                                files = matchFiles(new File (dir), PABLOSEXT);
    8787                               
    8888                                for(File file: files) {
  • proto/pablo/src/test/pabloS/grammar/TestPabloSAST.java

    r2755 r2767  
    33 * December 7 2012
    44 *
    5  * Quick and dirty test program to test PabloS grammar parser without error.
     5 * Quick and dirty test program to test PabloS grammar/parser.
    66 *
    77 * Input:       Top-level directory that contains *.pablo (PabloS) files.
     
    1212package test.pabloS.grammar;
    1313
    14 import java.io.BufferedReader;
    15 import java.io.FileNotFoundException;
    16 import java.io.FileReader;
    17 import java.io.IOException;
    18 import java.io.PrintStream;
     14import java.io.*;
     15import java.util.*;
    1916
    2017import  pabloS.applications.SampleApplication;
    21 import  pabloS.ast.ASTNode;
    22 import  pabloS.ast.ASTPrinter;
     18import  pabloS.ast.*;
    2319import  pabloS.parser.Parser;
    2420import  pabloS.lexicalAnalyzer.LexicalController;
    2521import  pabloS.tokens.Tokens;
     22import test.PabloApplication;
     23import test.helpers.TestUtil;
    2624
    27 import java.io.File;
    28 import java.util.ArrayList;
    29 import java.util.Collections;
    30 import java.util.List;
    3125
    3226public class TestPabloSAST extends SampleApplication {
    3327
     28        private static final String PABLOSEXT = ".pablos";
     29
    3430        public static void main(String[] args) throws FileNotFoundException {
     31               
    3532                PabloApplication.checkArgs(args, "TestPabloSAST");
    3633               
     
    3835                Tokens.setPrintLevel(Tokens.Level.TYPE_VALUE_SEQ);
    3936               
    40                 List<File> list = listFilesInDirectory(new File(args[0]),".pablo");
     37                List<File> list = TestUtil.listFilesInDirectory(new File(args[0]),PABLOSEXT);
    4138               
    4239                Collections.sort(list);
    4340               
    44                 for(File f : list) {
    45                         System.out.println(delimeterLine());
     41                for(File f: list) {
     42                        System.out.println(TestUtil.delimeterLine());
    4643                       
    4744                        System.out.println("File: " + f.getName() + "\n");     
     
    4946                        try {
    5047                                System.out.println("Code: \n" );
    51                                 System.out.println(file2String(f));
     48                                System.out.println(TestUtil.file2String(f));
    5249                        } catch (IOException e) {
    5350                                e.printStackTrace();
     
    6764                out.print(syntaxTree);
    6865        }
    69        
    70         public static List<File> listFilesInDirectory(File dir, String pattern) {
    71                 List<File> file = new ArrayList<File>();
    72                 File [] files = dir.listFiles();
    73                 if (files != null) {
    74                         for (File f : files) {
    75                                 if (f.isDirectory()) {
    76                                         file.addAll(listFilesInDirectory(f, pattern));
    77                                 }
    78                                 else {
    79                                         if (f.getName().endsWith(pattern)) {
    80                                                 file.add(f);
    81                                         }
    82                                 }
    83                         }
    84                 }
    85                 return file;
    86         }
    87        
    88     public static String file2String(File f) throws IOException {
    89         BufferedReader reader = new BufferedReader(new FileReader(f));
    90 
    91         StringBuffer buffer = new StringBuffer();
    92         String line = null;
    93         while ((line=reader.readLine()) != null) {
    94             buffer.append(line + "\n");
    95         }
    96 
    97         reader.close();
    98        
    99         return buffer.toString();
    100     }   
    101        
    102     public static String delimeterLine() {
    103         return new String("---");
    104     }
    10566   
    10667}
Note: See TracChangeset for help on using the changeset viewer.