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

General refactoring.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/pablo/src/compiler/codeGenerator/CodeGenerator.java

    r2702 r2710  
    55import compiler.ast.Accessors;
    66import compiler.ast.Generators;
    7 import compiler.codeGenerator.visitors.CPPUnparser;
    8 import compiler.codeGenerator.visitors.Unparser;
    9 import compiler.codeGenerator.visitors.helpers.CodeStore;
    10 import compiler.codeGenerator.visitors.helpers.UnparserUtil;
     7import compiler.backend.visitors.*;
     8import compiler.backend.visitors.helpers.CodeStore;
     9import compiler.backend.visitors.helpers.UnparserUtil;
    1110import compiler.lang.carryset.CarrySet2Lang;
    1211import compiler.lang.pablo.Builtins2Lang;
    13 import compiler.semanticAnalyzer.visitors.*;
    1412
    1513import ast.*;
    1614
    17 // Code Generator - Two Trees (i) do_block (ii) do_final_block
    18 
    19 // 1. do_block_code.
    20 // 2. do_final_block_code
    21 // 3.
    22 
    2315public class CodeGenerator {
    2416
    25         //private ASTNode cicoDecoratedASTTree;
    26         //private ASTNode coDecoratedASTTree;   
    27        
    2817        //////////////////////////////////////////////////////////////
    29         // static interface
    30        
    31         public static String makeStreamFuncDecls(ASTNode cicoASTTree, ASTNode coASTTree, Unparser unparser) {
     18        // static interface             
     19        /*
     20        public static String makeStreamFuncDecls(ProgramNode blockAST, ProgramNode finalBlockAST, Unparser unparser, int indent) {
     21                StringBuilder builder = new StringBuilder();
     22                List<FuncDefNode> funcDefs = Accessors.funcDefs((ProgramNode) node);
    3223               
    33                 StringBuilder builder = new StringBuilder();
    34                 List<FuncDefNode> cicoFuncDefs = Accessors.funcDefs((ProgramNode)cicoASTTree);
    35                
    36                 for(FuncDefNode funcDef: cicoFuncDefs) {
    37                         builder.append(unparser.getCode(funcDef));
     24                for(FuncDefNode funcDef: funcDefs) {
     25                        builder.append(makeStreamFuncDecl(funcDef, unparser, indent));
    3826                }       
    3927               
    4028                return builder.toString();
    4129        }       
     30        */
     31        /*
     32        struct @name {
     33               
     34                @name() {}
     35               
     36                IDISA_INLINE void do_block(@args) {
     37                        @do_block
     38                }
     39               
     40                IDISA_INLINE void do_final_block(@args) {
     41                        @do_final_block
     42                }
     43               
     44                IDISA_INLINE void do_segment(@args, int segment_blocks) {
     45                       
     46                }
     47               
     48                CarryArray<@carry_count, @carry_n_count> carryQ;
     49        };
     50        */
     51        /*
     52        public static String makeStreamFuncDecl(FuncDefNode node, Unparser unparser, int indent) {
     53               
     54                String funcName = Accessors.funcName(node);
     55               
    4256
    43         //////////////////////////////////////////////////////////////
    44         // constructor and helpers
     57               
     58                String parameters = Accessors.
     59
     60               
     61                return unparser.getCode(node, indent);
     62        }
     63        */
     64
     65        public static String makeStructDecls(ProgramNode node, Unparser unparser, int indent) {
     66                StringBuilder builder = new StringBuilder();
     67                List<StructTypeNode> structDecls = Accessors.structTypeDecls(node);
     68                for(StructTypeNode structDecl: structDecls) {
     69                        builder.append(makeStructDecl(structDecl, unparser, indent));
     70                }       
     71                return builder.toString();
     72        }       
     73       
     74        public static String makeStructDecl(StructTypeNode node, Unparser unparser, int indent) {
     75                return unparser.getCode(node, indent);
     76        }
    4577       
    4678        /*
    47         public static String makeStructDecls(ProgramNode node, Unparser unparser) {
    48                 String code = new String();
    49                 List<StructTypeNode> structDecls = Accessors.structTypeDecls(node);
    50                 for(StructTypeNode structDecl: structDecls) {
    51                         code += unparser.getCode(structDecl);
    52                 }       
    53                 return code;
    54         }       
    55                
    5679        public static String makeStructDefs(ProgramNode node, Unparser unparser) {
    5780                return unparser.getStructDefs(node, 0);
    5881        }
     82        */
    5983       
    6084        //////////////////////////////////////////////////////////////
    6185        //
    62         public String makeStructDefs(ProgramNode node, int indent) {
     86        /*
     87        public static String makeStructDefs(ProgramNode node, int indent) {
    6388                StringBuilder builder = new StringBuilder();
    6489                List<StructTypeNode> structDecls = Accessors.structTypeDecls(node);
    6590                for(StructTypeNode structDecl: structDecls) {
    66                         String name = Accessors.structName(structDecl);
    67                         CodeStore.addIndentation(builder, indent);
    68                         builder.append(Generators.capitalize(name));    // TODO - hack replace with 'real' stream kernels
    69                         builder.append(" ");
    70                         builder.append(Generators.unCapitalize(name));  // TODO - hack
    71                         builder.append(";");
    72                         builder.append(CodeStore.NEWLINE);
     91                        builder.append(makeStructDef(structDecl, indent));     
    7392                }
    7493                return builder.toString();
    7594        }
    7695       
    77         public String makeFuncDefs(ProgramNode node, int indent) {
     96        public static String makeStructDef(StructTypeNode node, int indent) {
     97                StringBuilder builder = new StringBuilder();
     98               
     99                String name = Accessors.structName(node);
     100                CodeStore.addIndentation(builder, indent);
     101                builder.append(Generators.capitalize(name));    // TODO -       hack
     102                builder.append(" ");                                                    //              replace capitalised struct type name and
     103                builder.append(Generators.unCapitalize(name));  //                      lower case instance name convention with a 'main' method         
     104                builder.append(";");
     105                builder.append(CodeStore.NEWLINE);
     106                               
     107                return builder.toString();
     108        }
     109       
     110        public static String makeFuncDefs(ProgramNode node, int indent) {
    78111                StringBuilder builder = new StringBuilder();
    79112                List<FuncDefNode> funcDefs = Accessors.funcDefs(node);
    80113                for(FuncDefNode funcDef: funcDefs) {
    81                         String name = Accessors.funcName(funcDef);
    82                         CodeStore.addIndentation(builder, indent);
    83                         builder.append(Generators.capitalize(name));    // TODO - hack replace with 'real' stream kernels
    84                         builder.append(" ");
    85                         builder.append(Generators.unCapitalize(name));  // TODO - hack
    86                         builder.append(";");
    87                         builder.append(CodeStore.NEWLINE);                     
     114                        builder.append(makeFuncDef(funcDef, indent));   
    88115                }       
    89116               
     
    91118        }
    92119       
    93         public String makeDoBlocks(ProgramNode node, int indent) {
     120        public static String makeFuncDef(FuncDefNode node, int indent) {
     121                StringBuilder builder = new StringBuilder();
     122               
     123                String name = Accessors.funcName(node);
     124                CodeStore.addIndentation(builder, indent);
     125                builder.append(Generators.capitalize(name));    // TODO - hack
     126                builder.append(" ");
     127                builder.append(Generators.unCapitalize(name)); 
     128                builder.append(";");
     129                builder.append(CodeStore.NEWLINE);
     130               
     131                return builder.toString();
     132        }
     133       
     134        /*
     135        public String makeFuncBodies(ProgramNode node, int indent) {
    94136                StringBuilder builder = new StringBuilder();
    95137                List<FuncDefNode> funcDefs = Accessors.funcDefs(node);
     
    102144                return null;
    103145        }
    104 
    105         public String makeDoFinalBlocks(ProgramNode node, int indent) {
    106                 StringBuilder builder = new StringBuilder();
    107                 List<FuncDefNode> funcDefs = Accessors.funcDefs(node);
    108                 for(FuncDefNode funcDef: funcDefs) {
    109                         String name = Accessors.funcName(funcDef);
    110                         CodeStore.addIndentation(builder, indent);
    111                         builder.append(Generators.unCapitalize(name));  // TODO - hack
    112                         builder.append(".doFinalBlock();");
    113                 }
    114                 return null;
     146       
     147        public String makeFuncBody(FuncDefNode node, indent) {
     148               
    115149        }
    116150        */
    117        
    118         /*
    119         public static String makeDoFinalBlockFinal(ASTNode root, Unparser unparser) {
    120                 CodeGenerator generator = new CodeGenerator(root, unparser);           
    121                 return generator.makeDoFinalBlock();
    122         }
    123         */             
    124151       
    125152        /*
Note: See TracChangeset for help on using the changeset viewer.