Changeset 2773


Ignore:
Timestamp:
Dec 12, 2012, 2:53:43 AM (6 years ago)
Author:
ksherdy
Message:

Added support for PabloB to CPP code generation.

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

Legend:

Unmodified
Added
Removed
  • proto/pablo/input/grammar/scatter/pabloB.scatter

    r2749 r2773  
    110110        optFuncDef                      #-> funcDef ;
    111111       
     112        // kernel CCGO // ?
     113       
    112114        //
    113115        // f u n c t i o n - l e v e l 
  • proto/pablo/input/test/pabloS/funcDef/funcDef2.pablos

    r2767 r2773  
    1 function stream FunXction(stream a, stream b, stream c) {};
     1struct bb {
     2        stream a;
     3
     4};
     5
     6/*
     7function stream Function(stream a, stream b, stream c) {
     8
     9
     10};
     11*/
  • proto/pablo/src/applications/ApplicationGenerator.java

    r2768 r2773  
    33//import ast.StartSymbolNode;
    44
     5import compiler.codeGenerator.visitors.CPPUnparser;
     6import compiler.codeGenerator.visitors.Unparser;
    57import compiler.lang.pabloS.*;
    68import compiler.lang.carryset.*;
    79import compiler.syntacticAnalysis.SyntacticAnalysisFailedException;
    810import compiler.syntacticAnalysis.SyntacticAnalyzer;
    9 import compiler.transformers.visitors.CPPXFormer;
    10 import compiler.transformers.visitors.CodeXFormer;
    11 import compiler.transformers.visitors.PabloS2PabloBXFormer;
     11import compiler.transformer.visitors.PabloS2PabloBXFormer;
    1212
    1313public class ApplicationGenerator {
     
    4444                Builtins2Lang builtins2Lang = null;
    4545                CarrySet2Lang carrySet2Lang = null;
    46                 CodeXFormer unparser = null;
     46                Unparser unparser = null;
    4747               
    4848                if(applicationConfig.targetLang.contentEquals(ApplicationConfig.CLANG)) {
     
    5353                        builtins2Lang = new Builtins2CPP();
    5454                        carrySet2Lang = new CarrySet2CPP();
    55                         unparser = new CPPXFormer();
     55                        unparser = new CPPUnparser();
    5656                }
    5757               
     
    6060               
    6161                // Transform
    62 
     62               
     63                PabloS2PabloBXFormer xFormer = new PabloS2PabloBXFormer();
     64                pabloB.ast.ASTNode node = xFormer.optXForm(syntaxTree, syntaxTree.deepCopy());
     65               
    6366                // Generate Code
    64                 PabloS2PabloBXFormer xFormer = new PabloS2PabloBXFormer();
    6567               
    66                 pabloB.ast.ASTNode node = xFormer.optXForm(syntaxTree, syntaxTree.deepCopy());
    67                                
    68                 // Build Template
     68                String code = unparser.getCode(node);
    6969               
    70                 ///CodeGenerator semanticAnalyzer = new CodeGenerator(syntaxTree, builtins2Lang, carrySet2Lang);
    71                 //ASTNode decorateTree = semanticAnalyzer.analyze();
    72 
    73                 // Generate Template
    74                                        
    75                 // Generate Code
     70                System.out.print(code);
     71               
     72                // Fill Template
     73               
    7674               
    7775                /*
     
    9088//              parser.copyTemplate("ReverseAccessibleArrayList");
    9189//              parser.copyTemplate("RevList");
    92                
    93                 // Fill Template
    94                
     90                               
    9591                printCompletionMessage();
    9692        }
  • proto/pablo/src/applications/TemplateContentsGenerator.java

    r2749 r2773  
    33import pabloS.ast.*;
    44import compiler.template.Template;
    5 import compiler.transformers.visitors.helpers.UnparserUtil;
     5import compiler.transformer.visitors.helpers.UnparserUtil;
    66import applications.ApplicationGenerator;
    77
  • proto/pablo/src/compiler/ast/pabloB/Accessors.java

    r2767 r2773  
    11package compiler.ast.pabloB;
     2
     3import compiler.ast.pabloB.Accessors;
    24
    35import pabloB.ast.*;
     
    1416        ////////////////////////////////////////////////////////////////////////////
    1517
    16        
    17         ////////////////////////////////////////////////////////////////////////////
    18         // FuncDefinitionNode helpers
     18        ////////////////////////////////////////////////////////////////////////////
     19        // Kernel Definition helpers
     20        ////////////////////////////////////////////////////////////////////////////
     21        public static boolean hasOptFuncDef(KernelDefNode node) {
     22                if(node.nChildren() > 1 && (node.child(2) instanceof FuncDefNode)) {
     23                        return true;
     24                }
     25                return false;
     26        }       
     27       
     28        public static FuncDefNode optFuncDefNode(KernelDefNode node) {
     29                assert hasOptFuncDef(node);
     30                return (FuncDefNode) node.child(2);
     31        }
     32       
     33        ////////////////////////////////////////////////////////////////////////////
     34        // Function Definition helpers
    1935        ////////////////////////////////////////////////////////////////////////////
    2036        public static IdentifierNode funcIdentifier(FuncDefNode node) {
     
    2642        }
    2743
     44        public static boolean hasParameters(FuncDefNode node) {
     45                ASTNode child2 = node.child(2);
     46               
     47                if ((node.nChildren()) > 2 && (child2 instanceof ParameterListNode)) {
     48                        return true;
     49                }
     50                return false;
     51        }       
     52               
     53        public static BlockStmtNode blockStmtNode(FuncDefNode node) {
     54                int blockStmtNodeIndex;
     55               
     56                if(Accessors.hasParameters(node)) {
     57                        blockStmtNodeIndex = 3;
     58                } else {
     59                        blockStmtNodeIndex = 2;
     60                }
     61               
     62                ASTNode child = node.child(blockStmtNodeIndex);
     63                assert child instanceof BlockStmtNode;
     64        return (BlockStmtNode) child;
     65        }       
     66       
     67        ////////////////////////////////////////////////////////////////////////////
     68        // Local Var Decl Stmts
     69        ////////////////////////////////////////////////////////////////////////////
     70       
     71        public static ASTNode lhs(LocalVarDeclNode node) {
     72                return node.child(1);
     73        }       
     74       
     75        public static ASTNode rhs(LocalVarDeclNode node) {
     76       
     77                return node.child(2);
     78        }               
     79       
     80        public static String assignOperator(LocalVarDeclNode node) {
     81                return node.getToken().getLexeme();
     82        }       
     83       
     84        public static boolean hasInitializationAssign(LocalVarDeclNode node) {
     85
     86                if (node.nChildren() > 2) {
     87                        return true;
     88                }
     89                return false;
     90        }       
     91       
     92        ////////////////////////////////////////////////////////////////////////////
     93        // Assign Stmts
     94        ////////////////////////////////////////////////////////////////////////////                           
     95        public static ASTNode lhs(AssignNode node) {
     96                return node.child(0);
     97        }       
     98       
     99        public static ASTNode rhs(AssignNode node) {
     100                return node.child(1);
     101        }       
     102
     103        public static String assignOperator(AssignNode node) {
     104                return node.getToken().getLexeme();
     105        }
     106               
     107        ////////////////////////////////////////////////////////////////////////////
     108        // Integer Constant
     109        ////////////////////////////////////////////////////////////////////////////           
     110        public static String integerConstant(IntegerConstantNode node) {
     111                return node.getToken().getLexeme();
     112        }                       
     113
     114        ////////////////////////////////////////////////////////////////////////////
     115        // String Constant
     116        ////////////////////////////////////////////////////////////////////////////           
     117        public static String stringConstant(StringConstantNode node) {
     118                return node.getToken().getLexeme();
     119        }               
     120       
     121        ////////////////////////////////////////////////////////////////////////////
     122        // IfStmtNode helpers
     123        ////////////////////////////////////////////////////////////////////////////   
     124        public static ASTNode ifTest(IfStmtNode node) {
     125                return (ASTNode) node.child(0);
     126        }
     127
     128        public static BlockStmtNode ifBlockStmt(IfStmtNode node) {
     129                return (BlockStmtNode) node.child(1);
     130        }       
     131       
     132        public static boolean hasElseBlockStmt(IfStmtNode node) {
     133                return node.nChildren() > 2;
     134        }
     135       
     136        public static BlockStmtNode elseBlockStmt(IfStmtNode node) {
     137                return (BlockStmtNode) node.child(2);
     138        }       
     139       
    28140        ////////////////////////////////////////////////////////////////////////////
    29141        // IdentifierNode helper
     
    34146        }
    35147       
     148        ////////////////////////////////////////////////////////////////////////////
     149        // Unary Operators
     150        ////////////////////////////////////////////////////////////////////////////                   
     151        public static ASTNode operand(UnaryOperatorNode node) {
     152                return node.child(0);
     153        }
     154
     155        public static String operator(UnaryOperatorNode node) {
     156                return node.getToken().getLexeme();
     157        }
     158       
     159        ////////////////////////////////////////////////////////////////////////////
     160        // Binary Operators
     161        ////////////////////////////////////////////////////////////////////////////           
     162        public static ASTNode lhs(BinaryOperatorNode node) {
     163                return node.child(0);
     164        }               
     165
     166        public static ASTNode rhs(BinaryOperatorNode node) {
     167                return node.child(1);
     168        }
     169       
     170        public static String operator(BinaryOperatorNode node) {
     171                return node.getToken().getLexeme();
     172        }               
     173
     174        ////////////////////////////////////////////////////////////////////////////
     175        // Terminals
     176        ////////////////////////////////////////////////////////////////////////////
     177        public static boolean isTerminal(ASTNode node) {
     178                return 0 == node.nChildren();
     179        }       
     180       
     181
     182        ////////////////////////////////////////////////////////////////////////////
     183        // StructTypeNode helper
     184        ////////////////////////////////////////////////////////////////////////////
     185        public static String structName(StructTypeNode node) {
     186        String name = new String();
     187        name = Accessors.name(node.child(0));
     188        return name;
     189        }
     190
     191        public static StructTypeBodyNode structBody(StructTypeNode node) {
     192                ASTNode child = node.child(1);
     193                assert child instanceof StructTypeBodyNode;
     194        return (StructTypeBodyNode) child;
     195        }       
     196       
     197        public static boolean hasStructBody(StructTypeNode node) {
     198                if (node.nChildren() > 1) {
     199                        ASTNode child = node.child(1);
     200                        assert child instanceof StructTypeBodyNode;
     201                        return true;
     202                }
     203                return false;
     204        }               
     205
     206        ////////////////////////////////////////////////////////////////////////////
     207        // Stream Type helpers
     208        ////////////////////////////////////////////////////////////////////////////
     209        public static String fieldWidthValue(FieldWidthNode node) {             
     210                return node.getToken().getLexeme();
     211        }       
     212
     213        ////////////////////////////////////////////////////////////////////////////
     214        // Void Type
     215        ////////////////////////////////////////////////////////////////////////////   
     216        public static String voidValue(VoidNode node) {         
     217                return node.getToken().getLexeme();
     218        }       
     219
    36220}
  • proto/pablo/src/compiler/codeGenerator/helpers/CodeFragments.java

    r2767 r2773  
    11package compiler.codeGenerator.helpers;
    2 
    3 import java.util.List;
    42
    53import compiler.lang.carryset.CarrySet2Lang;
    64import compiler.lang.pabloS.Builtins2Lang;
    7 import compiler.transformers.visitors.*;
    8 import compiler.transformers.visitors.helpers.CodeStore;
     5import compiler.transformer.visitors.*;
     6import compiler.transformer.visitors.helpers.CodeStore;
    97
    108import pabloS.ast.*;
    119
    12 public class Generators {
     10public class CodeFragments {
    1311
    1412        //////////////////////////////////////////////////////////////
  • proto/pablo/src/compiler/codeGenerator/visitors/CPPUnparser.java

    r2767 r2773  
    1 package compiler.transformers.visitors;
    2 
    3 import pabloS.ast.*;
     1package compiler.codeGenerator.visitors;
     2
     3import pabloB.ast.*;
    44
    55import java.util.Iterator;
    66import java.util.List;
    77
    8 //import compiler.codeGenerator.visitors.helpers.*;
    9 import compiler.ast.pabloS.Accessors;
    10 import compiler.lang.carryset.CarrySet2CPP;
    11 import compiler.lang.pabloS.Builtins2CPP;
    12 import compiler.transformers.visitors.helpers.CodeStore;
    13 import compiler.transformers.visitors.helpers.UnparserUtil;
     8import compiler.ast.pabloB.Accessors;
     9import compiler.transformer.visitors.helpers.CodeStore;
     10import compiler.transformer.visitors.helpers.UnparserUtil;
    1411
    1512//
    16 // This class transforms Pablo AST code to Block-at-a-time CPP code.
     13// Transforms PabloB AST to C++ code.
    1714//
    1815
    19 // For each stream function
    20 // (1) Deep copy of the stream function body for (a) non-final block body and (b) final block body).
    21 // (2) Apply final block transformation to non-final
    22 // (3) Transform (a) non-final block body to C++ do_block.
    23 // (4) Transform (b) final-block body to C++ do_final_block.
    24 // (5) carry_count, carry_n_count
    25 
    26 // An alternate design choices to make AST copies externally to this class and
    27 // then iterate over over stream function externally unparse, gather build the
    28 // C++ code. This option may promotes 'smaller' visitors and 'looser-coupling'.
    29 
    30 // Adoption of code templates and template composition may prove to be a valuable design choice (see Scatter).
    31 // The AnTLR String Template framework makes use of this strategy.
    32 
    33 // Pablo stream function target.
     16// CPP stream struct target.
     17/*
     18struct $name
     19{
     20        $members
     21};
     22*/
     23 
     24// CPP stream function target.
    3425/*             
    35 struct @name
     26struct $name
    3627{
    3728  @name() {}
    38   IDISA_INLINE void do_block(@parameters)
     29  IDISA_INLINE $ReturnType do_block($parameters)
    3930  {
    40         @do_block                               
     31        $block_statements                               
    4132  }
    42   IDISA_INLINE void do_final_block(@parameters, BitBlock & EOF_mask)
     33  IDISA_INLINE $ReturnType do_final_block($parameters)
    4334  {
    44     @do_final_block
     35    $block_statements
    4536  }                             
    46   CarryArray<@carry_count, @carry_n_count> carryQ;
     37  CarryArray<$carry_count, $carry_n_count> carryQ;
    4738};
    4839*/
    4940
    50 public class CPPXFormer extends CodeXFormer {
     41public class CPPUnparser extends Unparser {
    5142       
    5243        //////////////////////////////////////////////////////////////
    5344        // constructor and helpers     
    54         public CPPXFormer() {}
     45        public CPPUnparser() {}
    5546
    5647        public String getCode(ASTNode node) {
     
    6758        // visitors
    6859        public CodeStore visitLeave(ProgramNode node, List<CodeStore> childResults) {   
    69                 return  UnparserUtil.concatenatedChildrenCode(new CodeStore(), childResults, false);
    70         }
    71 
    72         //public void visitEnter(DeclsNode node) {
    73 
    74         //}
    75        
    76         //public CodeStore visitLeave(DeclsNode node, List<CodeStore> childResults) {   
    77         //      return UnparserUtil.concatenatedChildrenCode(new CodeStore(), childResults, true);             
    78         //}     
    79 
    80         public CodeStore visitLeave(TypeDefNode node, List<CodeStore> childResults) {
    81                 CodeStore code = new CodeStore();
    82                
    83                 String type = childResults.get(0).getResultVarName();
    84                 String alias = childResults.get(1).getResultVarName();
    85                
    86                 code.addFormattedLine("typedef %s %s;", type, alias);
    87                
    88                 return code;
    89         }       
     60                return  UnparserUtil.concatenatedChildrenCode(new CodeStore(), childResults, true);
     61        }
    9062       
    9163        public CodeStore visitLeave(TypeDeclNode node, List<CodeStore> childResults) {
    92                 CodeStore code = new CodeStore();
    93                 String type = childResults.get(0).getResultVarName();
    94                 String DeclList;
    95                 /*//Deprecated.
    96                 if (Accessors.hasDeclList(node)) {
    97                         DeclList = childResults.get(1).getResultVarName();
    98                         code.addFormattedLine("%s %s;", type, DeclList);
     64                return  UnparserUtil.concatenatedChildrenCode(new CodeStore(), childResults, true);
     65        }
     66       
     67        public CodeStore visitLeave(KernelDefNode node, List<CodeStore> childResults) {
     68                CodeStore code = new CodeStore();
     69               
     70                String kernelName = childResults.get(0).getResultVarName();
     71               
     72                CodeStore funcDefCodeStore = childResults.get(1);
     73               
     74                code.addFormattedLine("struct %s ", kernelName);
     75                code.addLine("{");
     76               
     77                code.addAll(funcDefCodeStore, 1);
     78               
     79                if(Accessors.hasOptFuncDef(node)) {
     80                        CodeStore optFuncDefCodeStore = childResults.get(2);
     81                        code.addAll(optFuncDefCodeStore, 0);
     82                }
     83               
     84                code.dedentedLine("}");
    9985                       
    100                 } else {
    101                 */
    102                         code.addFormattedLine("%s;", type);
    103                 //}
    104                 return code;           
    105         }               
    106 
    107         /*// deprecated
    108         public CodeStore visitLeave(DeclListNode node, List<CodeStore> childResults) {
    109                 CodeStore code = new CodeStore();
    110                 Iterator<CodeStore> iter = childResults.iterator();
    111                 code.setResultVarName(UnparserUtil.makeDelimitedList(iter, ", "));
    112                 return code;           
    113         }
    114         */
    115        
    116         ////////////////////////////////////////////////////////////////////////////
    117         // Stream Funcs - User defined stream function (language extension point)
     86                // TODO - Add carryQ data member
     87               
     88                return code;
     89        }
     90       
     91        ////////////////////////////////////////////////////////////////////////////
     92        // Stream Functions - User defined stream function (extension point)
    11893        ////////////////////////////////////////////////////////////////////////////
    11994        public CodeStore visitLeave(FuncDefNode node, List<CodeStore> childResults) {
    120                
    121                
    122                
    123                 CodeStore code = new CodeStore();
    124                 // CodeStore returnType = childResults.get(0);
    125                  
     95                       
     96                CodeStore code = new CodeStore();
     97               
     98                String returnType = childResults.get(0).getResultVarName();     
    12699                String funcName = childResults.get(1).getResultVarName();
    127100                String parameters = new String();
    128101                               
     102                CodeStore blockStmtCodeStore = null;
    129103                if(Accessors.hasParameters(node)) {
    130104                        parameters = childResults.get(2).getResultVarName();
    131                 }
    132                
    133                 // TODO - CarryArray carry_count ...
    134                
    135                 boolean isFinalBlock = false;
    136                 CodeStore nonFinalBlockCodeStore = XFormBlockStmt(Accessors.blockStmtNode(node), isFinalBlock);
    137                        
    138                 isFinalBlock = true;
    139                 CodeStore finalBlockCodeStore = XFormBlockStmt(Accessors.blockStmtNode(node), isFinalBlock);
    140                
    141                 code.addFormattedLine("struct %s", funcName);
     105                        blockStmtCodeStore = childResults.get(3);
     106                } else {
     107                        blockStmtCodeStore = childResults.get(2);
     108                }
     109               
     110                // TODO - Add IDISA_INLINE configuration option
     111                code.addFormattedLine("IDISA_INLINE %s %s (%s)", returnType, funcName, parameters);
    142112                code.addLine("{");
    143                 code.indentedFormattedLine("%s () {}", funcName);
    144                 code.addFormattedLine("IDISA_INLINE void do_block(%s)", parameters);
    145                 code.addLine("{");
    146                 code.addAll(nonFinalBlockCodeStore, 1);
     113                code.addAll(blockStmtCodeStore, 1);
    147114                code.dedentedLine("}");
    148                 code.addFormattedLine("IDISA_INLINE void do_final_block(%s)", parameters);
    149                 code.addLine("{");
    150                 code.addAll(finalBlockCodeStore, 1);
    151                 code.dedentedLine("}");
    152                 code.addFormattedLine("CarryArray<%s,%s> carryQ;", "99", "99"); // CGO
    153                 code.dedentedLine("};");
    154115                               
    155116                return code;
    156         }
    157 
    158         private CodeStore XFormBlockStmt(BlockStmtNode node, boolean isFinalBlock) {
    159                 BlockStmtNode copy = node.deepCopy();
    160                 Pablo2CarryXFormer pablo2CarryQ = new Pablo2CarryXFormer(copy, new Builtins2CPP(), new CarrySet2CPP());
    161                 pablo2CarryQ.XForm(isFinalBlock);                   
    162                 CodeStore codeStore = copy.accept(new CPPXFormer());
    163                 return codeStore;
    164117        }
    165118
  • proto/pablo/src/compiler/codeGenerator/visitors/Unparser.java

    r2755 r2773  
    1 package compiler.transformers.visitors;
     1package compiler.codeGenerator.visitors;
    22
    33
    4 import pabloS.ast.ASTNode;
    5 import pabloS.ast.ASTVisitor.Default;
    6 import compiler.transformers.visitors.helpers.CodeStore;
     4import pabloB.ast.ASTNode;
     5import pabloB.ast.ASTVisitor.Default;
     6import compiler.transformer.visitors.helpers.CodeStore;
    77
    8 abstract public class CodeXFormer extends Default<CodeStore> {
     8abstract public class Unparser extends Default<CodeStore> {
    99       
    1010        abstract public String getCode(ASTNode node);           
  • proto/pablo/src/compiler/syntacticAnalysis/SyntacticAnalysisFailedException.java

    r2713 r2773  
    33public class SyntacticAnalysisFailedException extends Exception {
    44
     5        /**
     6         *      Default
     7         */
     8        private static final long serialVersionUID = 1L;
     9
    510}
Note: See TracChangeset for help on using the changeset viewer.