Changeset 2687


Ignore:
Timestamp:
Nov 23, 2012, 5:25:52 PM (7 years ago)
Author:
ksherdy
Message:

Added methods to generate @global label.

Location:
proto/pablo
Files:
1 added
15 edited
1 copied

Legend:

Unmodified
Added
Removed
  • proto/pablo/ReadMe.txt

    r2686 r2687  
    111111   
    11211210. Semantic analyzer. Add Scatter logging.   
     113
     11411. Clone AST or not.
     115
     11611. X2Lang design decision. enum/assert etc...
     117
     11811. To clone the AST or not.
     119
     120        Options:
     121
     122        (a) Parse twice. Transform AST (AST_CICO_Mode AST2_CI_Mode). Generate code twice (once for each mode).
     123        (b) Clone complete AST. Transform AST (AST_CICO_Mode AST2_CI_Mode). Generate code (once for each mode).
     124        (c)
     125
  • proto/pablo/input/grammar/scatter/pablo.scatter

    r2686 r2687  
    7070
    7171grammar {
    72         program         -> (Decls | FuncDef) *;
     72        program         -> (typeDecl | typeDef | FuncDef) *;
    7373
    7474        //
     
    7979        // d e c l a r a t i o n s
    8080        //
    81         Decls                   -> (typeDecl | typeDef) TERMINATOR ;
    82 
    83         typeDecl                ->  type DeclList?;
     81        // Decls                        -> (typeDecl | typeDef) TERMINATOR ;
     82       
     83        // typeDecl             
     84
     85        typeDecl                ->  type TERMINATOR ; // DeclList?; // Disallow top-level instance decls
    8486               
    85         typeDef                 ->  TYPEDEF type identifier ;
    86        
    87         DeclList                ->  identifier (COMMA identifier)* ; // TODO
     87        typeDef                 ->  TYPEDEF type identifier TERMINATOR ;
     88       
     89        // DeclList             ->  identifier (COMMA identifier)* ;
    8890       
    8991   
    9092    //
    91         // f u n c t i o n   d e f i n i t i o n s                                                             
     93        // f u n c t i o n   d e f i n i t i o n s      // d e c l a r a t i o n s ?                                                   
    9294        //
    9395        FuncDef                 -> FUNCTION type FuncName LROUND parameterList? RROUND blockStmt TERMINATOR?;                           
  • proto/pablo/src/application/ApplicationGenerator.java

    r2686 r2687  
    33//import ast.StartSymbolNode;
    44import ast.ASTNode;
     5import ast.ProgramNode;
     6import compiler.codeGenerator.CodeGenerator;
     7import compiler.codeGenerator.visitors.CPPUnparser;
     8import compiler.codeGenerator.visitors.Unparser;
    59import compiler.lang.pablo.*;
    610import compiler.lang.carryset.*;
     
    2832                OutputCodeFolder.setWarningMessage(generatedCodeWarning);
    2933        }
    30 
     34       
    3135        //////////////////////////////////////////////////////////////////////////////////
    3236        // code generation
     
    4145//              OutputCodeFolder parser = new OutputCodeFolder(outputDirectory, srcDirectory);         
    4246
     47                // Target Lang
    4348                Builtins2Lang builtins2Lang = null;
    4449                CarrySet2Lang carrySet2Lang = null;
     50                Unparser unparser = null;
    4551               
    4652                if(applicationConfig.targetLang.contentEquals(ApplicationConfig.CLANG)) {
    4753                        //builtins2Lang = new Builtins2C();
    48                         //carrySet2Lang = new CarrySet2C();                             
     54                        //carrySet2Lang = new CarrySet2C();     
     55                        //unparser = new CUnparser();
    4956                } else {
    5057                        builtins2Lang = new Builtins2CPP();
    51                         carrySet2Lang = new CarrySet2CPP();             
     58                        carrySet2Lang = new CarrySet2CPP();
     59                        unparser = new CPPUnparser();
    5260                }
    5361               
    54                 // Parse
     62                // Transformation Mode ci/co, ci
     63               
    5564                ASTNode syntaxTree = SyntacticAnalyzer.parse(applicationConfig.inputFile);
    56                                
    57                 // Analyze
     65               
     66                                               
     67                /*
     68               
     69                // Analyze and transform the AST
     70                SemanticAnalyzer semanticAnalyzer = new SemanticAnalyzer(syntaxTree);
     71                semanticAnalyzer.setTargetLang();
     72                semanticAnalzyer.setMode();
     73                ASTNode decorateCiCoTree = semanticAnalyzer.analyze();
     74
     75                //
     76                ASTNode syntaxTree = SyntacticAnalyzer.parse(applicationConfig.inputFile);
     77                       
     78                SemanticAnalyzer semanticAnalyzer = new SemanticAnalyzer(syntaxTree);
     79                semanticAnalyzer.setTargetLang();
     80                semanticAnalzyer.setMode();
     81                ASTNode decorateCoTree = semanticAnalyzer.analyze();
     82               
     83                ASTNode syntaxTree = SyntacticAnalyzer.parse(applicationConfig.inputFile);
     84               
     85                ASTNode SyntaxTree = SyntacticAnalyzer.parse(applicationConfig.inputFile);
     86                semanticAnalyzer.setTargetLang();
     87                semanticAnalzyer.setMode();
    5888                SemanticAnalyzer semanticAnalyzer = new SemanticAnalyzer(syntaxTree, builtins2Lang,     carrySet2Lang);
    59                 semanticAnalyzer.setAddDumpStmts(applicationConfig.addDumpStmts);
    60                 semanticAnalyzer.setAddAssertBitBlockAlignStmts(applicationConfig.addAssertBitBlockAlignStmts);
    61                 ASTNode decoratedTree = semanticAnalyzer.analyze();
     89                */
     90                // Generate
     91                                       
     92                String global = CodeGenerator.makeStructDecls((ProgramNode)syntaxTree, unparser);
    6293               
    63                 // Generate
     94                global +=  CodeGenerator.makeStreamFuncDecls((ProgramNode)syntaxTree, unparser);
     95               
     96                System.out.print(global);
    6497                                       
    6598//              parser.generateFile(new TemplateContentsGenerator(this.root, srcDirectory), "Parser.java"); // "Parser.java"
  • proto/pablo/src/application/Pablo.java

    r2686 r2687  
    4040                        applicationGenerator.generate();
    4141                } catch (Exception e) {
     42                       
     43                        e.printStackTrace();
     44                       
    4245                        ApplicationOptions.exitWithUsageMessage(options);
    4346                }       
  • proto/pablo/src/application/TemplateContentsGenerator.java

    r2670 r2687  
    22
    33import ast.*;
    4 import compiler.codeGenerator.visitors.Unparser;
     4import compiler.codeGenerator.visitors.helpers.UnparserUtil;
    55import compiler.template.Template;
    66import application.ApplicationGenerator;
     
    1313        private ASTNode ASTTree;
    1414    private Template template;
    15     private Unparser codeGenerator;
     15    private UnparserUtil codeGenerator;
    1616//      private String outputDirectory;
    1717       
  • proto/pablo/src/ast/ASTTransformer.java

    r2660 r2687  
    2222        public ASTNode visit(CompoundIdentifierNode node);
    2323
    24         public ASTNode visit(DeclListNode node);
    25 
    26         public ASTNode visit(DeclsNode node);
    27 
    2824        public ASTNode visit(EpsilonNode node);
    2925
     
    107103                }
    108104
    109                 public ASTNode visit(DeclListNode node) {
    110                         return defaultVisit(node);
    111                 }
    112 
    113                 public ASTNode visit(DeclsNode node) {
    114                         return defaultVisit(node);
    115                 }
    116 
    117105                public ASTNode visit(EpsilonNode node) {
    118106                        return defaultVisit(node);
  • proto/pablo/src/ast/ASTVisitor.java

    r2660 r2687  
    2929        public T visitLeave(CompoundIdentifierNode node, List<T> childResults);
    3030
    31         public void visitEnter(DeclListNode node);
    32         public T visitLeave(DeclListNode node, List<T> childResults);
    33 
    34         public void visitEnter(DeclsNode node);
    35         public T visitLeave(DeclsNode node, List<T> childResults);
    36 
    3731        public void visitEnter(EpsilonNode node);
    3832        public T visitLeave(EpsilonNode node, List<T> childResults);
     
    169163                }
    170164
    171                 public void visitEnter(DeclListNode node) {
    172                         defaultVisitEnter(node);
    173                 }
    174                 public T visitLeave(DeclListNode node, List<T> childResults) {
    175                         return defaultVisitLeave(node);
    176                 }
    177 
    178                 public void visitEnter(DeclsNode node) {
    179                         defaultVisitEnter(node);
    180                 }
    181                 public T visitLeave(DeclsNode node, List<T> childResults) {
    182                         return defaultVisitLeave(node);
    183                 }
    184 
    185165                public void visitEnter(EpsilonNode node) {
    186166                        defaultVisitEnter(node);
  • proto/pablo/src/ast/SimpleVisitor.java

    r2660 r2687  
    2323        public void visit(CompoundIdentifierNode node);
    2424
    25         public void visit(DeclListNode node);
    26 
    27         public void visit(DeclsNode node);
    28 
    2925        public void visit(EpsilonNode node);
    3026
     
    108104                }
    109105
    110                 public void visit(DeclListNode node) {
    111                         defaultVisit(node);
    112                 }
    113 
    114                 public void visit(DeclsNode node) {
    115                         defaultVisit(node);
    116                 }
    117 
    118106                public void visit(EpsilonNode node) {
    119107                        defaultVisit(node);
  • proto/pablo/src/ast/VoidVisitor.java

    r2660 r2687  
    2727        public void visitLeave(CompoundIdentifierNode node);
    2828
    29         public void visitEnter(DeclListNode node);
    30         public void visitLeave(DeclListNode node);
    31 
    32         public void visitEnter(DeclsNode node);
    33         public void visitLeave(DeclsNode node);
    34 
    3529        public void visitEnter(EpsilonNode node);
    3630        public void visitLeave(EpsilonNode node);
     
    166160                }
    167161
    168                 public void visitEnter(DeclListNode node) {
    169                         defaultVisitEnter(node);
    170                 }
    171                 public void visitLeave(DeclListNode node) {
    172                         defaultVisitLeave(node);
    173                 }
    174 
    175                 public void visitEnter(DeclsNode node) {
    176                         defaultVisitEnter(node);
    177                 }
    178                 public void visitLeave(DeclsNode node) {
    179                         defaultVisitLeave(node);
    180                 }
    181 
    182162                public void visitEnter(EpsilonNode node) {
    183163                        defaultVisitEnter(node);
  • proto/pablo/src/compiler/ast/Accessors.java

    r2686 r2687  
    1717        ////////////////////////////////////////////////////////////////////////////
    1818
    19        
     19        ////////////////////////////////////////////////////////////////////////////
     20        // Program (global)
     21        ////////////////////////////////////////////////////////////////////////////
     22        public static List<StructTypeNode> structTypeDecls(ProgramNode node) {
     23               
     24                List<StructTypeNode> structTypeDecls = new ArrayList<StructTypeNode>();
     25               
     26                for(ASTNode child: node.getChildren()) {
     27                        if (child instanceof TypeDeclNode) {
     28                                ASTNode type = child.child(0);
     29                                if(type instanceof StructTypeNode) {
     30                                        structTypeDecls.add((StructTypeNode)type);
     31                                }
     32                        }
     33                }
     34               
     35                return structTypeDecls;
     36        }
     37
     38        public static List<FuncDefNode> funcDefs(ProgramNode node) {
     39               
     40                List<FuncDefNode> funcDefs = new ArrayList<FuncDefNode>();
     41               
     42                for(ASTNode child: node.getChildren()) {
     43                        if (child instanceof FuncDefNode) {
     44                                funcDefs.add((FuncDefNode)child);
     45                        }
     46                }
     47                return funcDefs;
     48        }
     49               
     50        ////////////////////////////////////////////////////////////////////////////
     51        // Terminals
     52        ////////////////////////////////////////////////////////////////////////////
    2053        public static boolean isTerminal(ASTNode node) {
    2154                return 0 == node.nChildren();
    2255        }
    23        
     56               
    2457        ////////////////////////////////////////////////////////////////////////////
    2558        // Type Decls
     
    294327
    295328        ////////////////////////////////////////////////////////////////////////////
    296         //
     329        // Stream Type helpers
    297330        ////////////////////////////////////////////////////////////////////////////
    298331        public static String fieldWidthValue(FieldWidthNode node) {             
     
    301334
    302335        ////////////////////////////////////////////////////////////////////////////
    303         //
     336        // Void Type
    304337        ////////////////////////////////////////////////////////////////////////////   
    305338        public static String voidValue(VoidNode node) {         
  • proto/pablo/src/compiler/codeGenerator/CodeGenerator.java

    r2671 r2687  
    11package compiler.codeGenerator;
     2
     3import java.util.List;
     4
     5import compiler.ast.Accessors;
     6import compiler.codeGenerator.visitors.CPPUnparser;
     7import compiler.codeGenerator.visitors.Unparser;
     8import compiler.codeGenerator.visitors.helpers.CodeStore;
     9import compiler.codeGenerator.visitors.helpers.UnparserUtil;
     10import compiler.lang.carryset.CarrySet2Lang;
     11import compiler.lang.pablo.Builtins2Lang;
     12import compiler.semanticAnalyzer.visitors.*;
     13
     14import ast.*;
     15
     16// Code Generator - Two Trees (i) do_block (ii) do_final_block
     17
     18// 1. do_block_code.
     19// 2. do_final_block_code
     20// 3.
    221
    322public class CodeGenerator {
    423
    5 }
     24        //////////////////////////////////////////////////////////////
     25        // static interface
     26        public static String makeStreamFuncDecls(ProgramNode node, Unparser unparser) {
     27                String code = new String();
     28                List<FuncDefNode> funcDefs = Accessors.funcDefs(node);
     29                for(FuncDefNode funcDef: funcDefs) {
     30                        code += unparser.getCode(funcDef);
     31                }       
     32                return code;
     33        }       
     34       
     35        public static String makeStructDecls(ProgramNode node, Unparser unparser) {
     36                String code = new String();
     37                List<StructTypeNode> structDecls = Accessors.structTypeDecls(node);
     38                for(StructTypeNode structDecl: structDecls) {
     39                        code += unparser.getCode(structDecl);
     40                }       
     41                return code;
     42        }       
     43               
     44        /*
     45        public static String makeDoBlock(ASTNode root, Unparser unparser) {
     46                CodeGenerator generator = new CodeGenerator(root, unparser);           
     47                return generator.makeDoBlock();
     48        }
     49        */     
     50       
     51        /*
     52        public static String makeDoFinalBlockFinal(ASTNode root, Unparser unparser) {
     53                CodeGenerator generator = new CodeGenerator(root, unparser);           
     54                return generator.makeDoFinalBlock();
     55        }
     56        */             
     57       
     58        /*
     59        public static String makeStreamStructDecls(ASTNode root, Unparser unparser) {
     60                CodeGenerator generator = new CodeGenerator(root, unparser);           
     61                return generator.makeStreamStructDecls();
     62        }
     63        */             
     64       
     65        /*
     66        public static String makeStreamFuncDefs(ASTNode root, Unparser unparser) {
     67                CodeGenerator generator = new CodeGenerator(root, unparser);           
     68                return generator.makeStreamFuncDefs();
     69        }
     70        */     
     71       
     72       
     73        // any_carry // TODO - deprecate
     74       
     75        //////////////////////////////////////////////////////////////
     76        // constructor and helpers
     77
     78
     79        //////////////////////////////////////////////////////////////
     80        // analysis
     81        /*
     82        public String makeStructDecls() {
     83               
     84                // Add logic
     85               
     86                String code = unparser.getCode();
     87                return code;
     88        }
     89        */
     90}               
     91
  • proto/pablo/src/compiler/codeGenerator/visitors/CPPUnparser.java

    r2671 r2687  
    22
    33import ast.*;
     4
    45import java.util.Iterator;
    56import java.util.List;
    67
    7 
    88import compiler.ast.Accessors;
    9 import compiler.codeGenerator.visitors.helpers.CodeStore;
    10 
    11 /*
    12  * Description: CodeStore get/set Vars are used to pass text fragments
    13  *                              that do not constitute output lines.
    14  */
     9import compiler.codeGenerator.visitors.helpers.*;
    1510
    1611public class CPPUnparser extends Unparser {
    17 
    18 //      private Labeller labeller = new Labeller();
    19 
    20         public CPPUnparser(ASTNode astTree) {
    21                 this.astTree = astTree;
    22         }
    23                        
    24         /*
    25         public T defaultVisit(ASTNode node) {
    26                 return null;
    27         }
    28        
    29         public void visitEnter(StructTypeNode node) {
    30                 defaultVisitEnter(node);
    31         }
    32         */
    33 
     12       
     13        //////////////////////////////////////////////////////////////
     14        // constructor and helpers     
     15        public CPPUnparser() {}
     16
     17        public String getCode(ASTNode node) {
     18                CodeStore codeStore = (CodeStore)node.accept(this);             
     19                return codeStore.toStringIndented(0);
     20        }               
     21
     22        public String getCode(ASTNode node, int indent) {
     23                CodeStore codeStore = (CodeStore)node.accept(this);             
     24                return codeStore.toStringIndented(indent);
     25        }
     26       
     27        //////////////////////////////////////////////////////////////
     28        // visitors
     29       
    3430        public CodeStore visitLeave(ProgramNode node, List<CodeStore> childResults) {   
    35                 return  concatenatedChildrenCode(new CodeStore(), childResults, false);
    36         }
    37 
    38         public void visitEnter(DeclsNode node) {
    39 
    40         }
    41        
    42         public CodeStore visitLeave(DeclsNode node, List<CodeStore> childResults) {     
    43                 return concatenatedChildrenCode(new CodeStore(), childResults, true);           
    44         }       
     31                return  UnparserUtil.concatenatedChildrenCode(new CodeStore(), childResults, false);
     32        }
     33
     34        //public void visitEnter(DeclsNode node) {
     35
     36        //}
     37       
     38        //public CodeStore visitLeave(DeclsNode node, List<CodeStore> childResults) {   
     39        //      return UnparserUtil.concatenatedChildrenCode(new CodeStore(), childResults, true);             
     40        //}     
    4541
    4642        public CodeStore visitLeave(TypeDefNode node, List<CodeStore> childResults) {
     
    7268                CodeStore code = new CodeStore();
    7369                Iterator<CodeStore> iter = childResults.iterator();
    74                 code.setResultVarName(makeDelimitedList(iter, ", "));
     70                code.setResultVarName(UnparserUtil.makeDelimitedList(iter, ", "));
    7571                return code;           
    7672        }               
     
    108104                CodeStore code = new CodeStore();               
    109105                Iterator<CodeStore> iter = childResults.iterator();
    110                 code.setResultVarName(makeDelimitedList(iter, ", "));           
     106                code.setResultVarName(UnparserUtil.makeDelimitedList(iter, ", "));             
    111107                return code;
    112108        }
     
    163159                CodeStore code = new CodeStore();
    164160                Iterator<CodeStore> iter = childResults.iterator();
    165                 code.setResultVarName(makeDelimitedList(iter, ", "));
     161                code.setResultVarName(UnparserUtil.makeDelimitedList(iter, ", "));
    166162                return code;
    167163        }
     
    341337        // Stream Structures
    342338        ////////////////////////////////////////////////////////////////////////////
    343 
    344         // Struct Type
     339        // Struct Type - used both as a variable and as sequence of lines
     340        //
    345341        public CodeStore visitLeave(StructTypeNode node, List<CodeStore> childResults) {
    346342
     
    351347                CodeStore structName = (CodeStore) childResults.get(0);
    352348
     349                // set variable
    353350                resultVar.append("struct");
    354351                resultVar.append(" ");
     
    362359                        resultVar.append("}");
    363360                }
    364 
    365361                code.setResultVarName(resultVar.toString());
     362
     363                // code store lines
     364                code.addFormattedLine("struct %s", structName.getResultVarName());
     365                code.addLine("{");
     366                if(Accessors.hasStructBody(node)) {
     367                        code.addAll(childResults.get(1),0);
     368                }
     369                code.dedentedLine("}");
    366370
    367371                return code;
     
    372376        public CodeStore visitLeave(StructTypeBodyNode node, List<CodeStore> childResults) {
    373377                CodeStore code = new CodeStore();
     378                /*
    374379                for (CodeStore child: childResults.subList(0, 1)) {
    375                         code.addAll(child,1);
     380                        code.addLine(child.toString(),1);
    376381                }
    377382                for (CodeStore child: childResults.subList(1, childResults.size())) {
    378                         code.addAll(child, 0);         
     383                        code.addLine(child.toString(),0);
    379384                }       
     385                */
     386                code.addAll(childResults.get(0),1);
     387               
    380388                return code;
    381389        }
     
    435443                CodeStore code = new CodeStore();
    436444                Iterator<CodeStore> iter = childResults.iterator();
    437                 code.setResultVarName(makeDelimitedList(iter, "."));
     445                code.setResultVarName(UnparserUtil.makeDelimitedList(iter, "."));
    438446                return code;
    439447        }
  • proto/pablo/src/compiler/codeGenerator/visitors/Unparser.java

    r2671 r2687  
    11package compiler.codeGenerator.visitors;
    22
    3 import ast.*;
    4 import java.util.Iterator;
    5 import java.util.List;
     3import ast.ASTNode;
     4import ast.ASTVisitor.Default;
    65
    76import compiler.codeGenerator.visitors.helpers.CodeStore;
    87
     8abstract public class Unparser extends Default<CodeStore> {
    99
    10 public abstract class Unparser extends ASTVisitor.Default<CodeStore> {
    11                
    12         protected ASTNode astTree;
    13        
    14         public String getCode() {
    15         CodeStore codeStore = (CodeStore)astTree.accept(this);
    16         return codeStore.toStringIndented(0);
    17     }
    18                
    19         public CodeStore concatenatedChildrenCode(List<CodeStore> childResults) {
    20                 return concatenatedChildrenCode(new CodeStore(), childResults, false);
    21         }
    22        
    23         public CodeStore concatenatedChildrenCode(CodeStore code, List<CodeStore> childResults, boolean blankBetween) {
    24                 for(CodeStore childCode: childResults) {
    25                         code.addAll(childCode, 0);
    26                         if(blankBetween) {
    27                                 code.addLine(" ");
    28                         }
    29                 }
    30                 return code;
    31         }
    32        
    33         public String makeDelimitedList(Iterator<CodeStore> iter, String delimeter) {
    34                 StringBuilder resultVar = new StringBuilder();
    35                 while (iter.hasNext()) {
    36                         resultVar.append(iter.next().getResultVarName());
    37                         if (iter.hasNext()) {
    38                                 resultVar.append(delimeter);
    39                         }
    40                 }
    41                 return resultVar.toString();
    42         }       
    43        
     10        abstract public String getCode(ASTNode node);
     11        abstract public String getCode(ASTNode node, int indent);
     12
    4413}
  • proto/pablo/src/compiler/codeGenerator/visitors/helpers/UnparserUtil.java

    r2685 r2687  
    1 package compiler.codeGenerator.visitors;
     1package compiler.codeGenerator.visitors.helpers;
    22
    33import ast.*;
     4
    45import java.util.Iterator;
    56import java.util.List;
    67
    7 import compiler.codeGenerator.visitors.helpers.CodeStore;
    8 
    9 
    10 public abstract class Unparser extends ASTVisitor.Default<CodeStore> {
    11                
    12         protected ASTNode astTree;
    13        
    14         public String getCode() {
    15         CodeStore codeStore = (CodeStore)astTree.accept(this);
    16         return codeStore.toStringIndented(0);
    17     }
    18                
    19         public CodeStore concatenatedChildrenCode(List<CodeStore> childResults) {
     8public abstract class UnparserUtil extends ASTVisitor.Default<CodeStore> {
     9                       
     10        public static CodeStore concatenatedChildrenCode(List<CodeStore> childResults) {
    2011                return concatenatedChildrenCode(new CodeStore(), childResults, false);
    2112        }
    2213       
    23         public CodeStore concatenatedChildrenCode(CodeStore code, List<CodeStore> childResults, boolean blankBetween) {
     14        public static CodeStore concatenatedChildrenCode(CodeStore code, List<CodeStore> childResults, boolean blankBetween) {
    2415                for(CodeStore childCode: childResults) {
    2516                        code.addAll(childCode, 0);
     
    3122        }
    3223       
    33         public String makeDelimitedList(Iterator<CodeStore> iter, String delimeter) {
     24        public static String makeDelimitedList(Iterator<CodeStore> iter, String delimeter) {
    3425                StringBuilder resultVar = new StringBuilder();
    3526                while (iter.hasNext()) {
  • proto/pablo/src/compiler/semanticAnalyzer/SemanticAnalyzer.java

    r2686 r2687  
    33import compiler.ast.Accessors;
    44import compiler.codeGenerator.visitors.CPPUnparser;
    5 import compiler.codeGenerator.visitors.Unparser;
     5import compiler.codeGenerator.visitors.helpers.UnparserUtil;
    66import compiler.lang.carryset.CarrySet2Lang;
    77import compiler.lang.pablo.Builtins2Lang;
     
    1414
    1515        private ASTNode root;
     16        private boolean ciMode;
     17        private boolean coMode;
     18       
    1619        private Builtins2Lang builtins2Lang;
    1720        private CarrySet2Lang carrySet2Lang;
     
    2023        private boolean addAssertBitBlockAlignStmts;
    2124       
     25       
    2226        //////////////////////////////////////////////////////////////
    2327        // static interface
    2428               
    25         public static ASTNode analyze(ASTNode root, Builtins2Lang builtins2Lang, CarrySet2Lang carrySet2Lang) {
    26                 SemanticAnalyzer analyzer = new SemanticAnalyzer(root, builtins2Lang, carrySet2Lang);           
     29        public static ASTNode analyze(ASTNode root) {
     30                SemanticAnalyzer analyzer = new SemanticAnalyzer(root);         
    2731                return analyzer.analyze();
    2832        }       
    29 
    30         public static ASTNode analyze(ASTNode root, Builtins2Lang builtins2Lang, CarrySet2Lang carrySet2Lang, boolean addDumpStmts, boolean addAssertBitBlockAlignStmts) {
    31                 SemanticAnalyzer analyzer = new SemanticAnalyzer(root, builtins2Lang, carrySet2Lang);
    32                 analyzer.setAddDumpStmts(addDumpStmts);
    33                 analyzer.setAddAssertBitBlockAlignStmts(addAssertBitBlockAlignStmts);
    34                 return analyzer.analyze();
    35         }               
    3633       
    3734        //////////////////////////////////////////////////////////////
    3835        // constructor and helpers
    3936       
    40         public SemanticAnalyzer(ASTNode root, Builtins2Lang builtins2Lang, CarrySet2Lang carrySet2Lang) {               
    41                 this.root = root;
    42                 this.builtins2Lang = builtins2Lang;
    43                 this.carrySet2Lang = carrySet2Lang;
    44                
     37        public SemanticAnalyzer(ASTNode root) {         
     38                this.root = root;               
    4539                this.setAddDumpStmts(false);
    4640                this.setAddAssertBitBlockAlignStmts(false);
     41               
     42                //
     43                // CPP builtins2Lang
     44                // CPP carrySet2Lang
     45                //
     46
     47                this.setCiMode(true);
     48                this.setCoMode(false);
    4749        }       
    4850
     51        //////////////////////////////////////////////////////////////
     52        // set defaults
     53        //
     54        //
     55        //
     56        //
     57       
    4958        //////////////////////////////////////////////////////////////
    5059        // analysis
     
    5766                AugAssign.XForm();
    5867               
    59                 CarryIntroXFormer carryQIntro = new CarryIntroXFormer(root, carrySet2Lang);
    60                 carryQIntro.XForm(true, false);
     68                CarryIntroXFormer carryQIntro = new CarryIntroXFormer(root, getCarrySet2Lang());
     69                carryQIntro.XForm(ciMode, coMode);
    6170               
    62                 Pablo2CarryXFormer pablo2CarryQ = new Pablo2CarryXFormer(root, builtins2Lang, carrySet2Lang);
    63                 pablo2CarryQ.XForm(true, false);                   
     71                Pablo2CarryXFormer pablo2CarryQ = new Pablo2CarryXFormer(root, getBuiltins2Lang(), getCarrySet2Lang());
     72                pablo2CarryQ.XForm(ciMode, coMode);                 
    6473           
    65                 AssertZeroXFormer assertZeroXFormer = new AssertZeroXFormer(root, builtins2Lang);
     74                AssertZeroXFormer assertZeroXFormer = new AssertZeroXFormer(root, getBuiltins2Lang());
    6675                assertZeroXFormer.XForm();
    6776               
     
    7180               
    7281                if(isAddDumpStmts()) {
    73                         DumpAssignStmtsXFormer dumpAssignStmtsXFormer = new DumpAssignStmtsXFormer(root, builtins2Lang); 
     82                        DumpAssignStmtsXFormer dumpAssignStmtsXFormer = new DumpAssignStmtsXFormer(root, getBuiltins2Lang()); 
    7483                        dumpAssignStmtsXFormer.XForm();
    7584                }
    7685               
    7786                if(isAddAssertBitBlockAlignStmts()) {
    78                         AssertBitBlockAlignStmtsXFormer assertBitBlockAlignStmtsXFormer = new AssertBitBlockAlignStmtsXFormer(root, builtins2Lang, carrySet2Lang); 
     87                        AssertBitBlockAlignStmtsXFormer assertBitBlockAlignStmtsXFormer = new AssertBitBlockAlignStmtsXFormer(root, getBuiltins2Lang(), getCarrySet2Lang()); 
    7988                        assertBitBlockAlignStmtsXFormer.XForm();
    8089                }                                       
    81                
    82                 Unparser cPPUnparser = new CPPUnparser(root);
    83                 String code = cPPUnparser.getCode();
    84                 System.out.print(code);
    8590               
    8691                return root;
     
    102107                this.addAssertBitBlockAlignStmts = addAssertBitBlockAlignStmts;
    103108        }
     109
     110        private Builtins2Lang getBuiltins2Lang() {
     111                return builtins2Lang;
     112        }
     113
     114        private void setBuiltins2Lang(Builtins2Lang builtins2Lang) {
     115                this.builtins2Lang = builtins2Lang;
     116        }
     117
     118        private CarrySet2Lang getCarrySet2Lang() {
     119                return carrySet2Lang;
     120        }
     121
     122        private void setCarrySet2Lang(CarrySet2Lang carrySet2Lang) {
     123                this.carrySet2Lang = carrySet2Lang;
     124        }       
     125       
     126        private boolean isCiMode() {
     127                return ciMode;
     128        }
     129
     130        private void setCiMode(boolean ciMode) {
     131                this.ciMode = ciMode;
     132        }
     133
     134        private boolean isCoMode() {
     135                return coMode;
     136        }
     137
     138        private void setCoMode(boolean coMode) {
     139                this.coMode = coMode;
     140        }
    104141       
    105142}               
  • proto/pablo/src/parser/Parser.java

    r2660 r2687  
    4949                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    5050                while( nowReading.isLextant(Lextant.FUNCTION, Lextant.STREAM, Lextant.STRUCT, Lextant.TYPEDEF, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    51                         if( nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.TYPEDEF, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     51                        if( nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    5252                                {
    53                                         ASTNode child = parseDecls();
     53                                        ASTNode child = parseTypeDecl();
     54                                        result.appendChild(child);
     55                                        allChildren.add(child);
     56                                }
     57                        }
     58                        else if( nowReading.isLextant(Lextant.TYPEDEF) ) {
     59                                {
     60                                        ASTNode child = parseTypeDef();
    5461                                        result.appendChild(child);
    5562                                        allChildren.add(child);
     
    7077        }
    7178         
    72         public ASTNode parseDecls() {
    73                 if( !(nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.TYPEDEF, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    74                         return syntaxErrorNode("Decls² [IDENTIFIER¹, STREAM¹, STRUCT¹, TYPEDEF¹, VOID¹]");
    75                 }
    76        
    77                 boolean allowCompression = true;
    78                 ASTNode result = new DeclsNode(nowReading);
    79                 result.setProductionTag(2);
    80                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    81                 if( nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    82                         {
    83                                 ASTNode child = parseTypeDecl();
    84                                 result.appendChild(child);
    85                                 allChildren.add(child);
    86                         }
    87                 }
    88                 else if( nowReading.isLextant(Lextant.TYPEDEF) ) {
    89                         {
    90                                 ASTNode child = parseTypeDef();
    91                                 result.appendChild(child);
    92                                 allChildren.add(child);
    93                         }
    94                 }
    95                 expect(Lextant.TERMINATOR);
    96                 if(allowCompression) {
    97                         return result;
    98                 }
    99                 return result;
    100         }
    101          
    10279        public ASTNode parseTypeDecl() {
    10380                if( !(nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     
    10784                boolean allowCompression = true;
    10885                ASTNode result = new TypeDeclNode(nowReading);
    109                 result.setProductionTag(3);
     86                result.setProductionTag(2);
    11087                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11188                {
     
    11491                        allChildren.add(child);
    11592                }
    116                 if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    117                         {
    118                                 ASTNode child = parseDeclList();
    119                                 result.appendChild(child);
    120                                 allChildren.add(child);
    121                         }
    122                 }
     93                expect(Lextant.TERMINATOR);
    12394                if(allowCompression) {
    12495                        return result;
     
    134105                boolean allowCompression = true;
    135106                ASTNode result = new TypeDefNode(nowReading);
    136                 result.setProductionTag(4);
     107                result.setProductionTag(3);
    137108                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    138109                expect(Lextant.TYPEDEF);
     
    147118                        allChildren.add(child);
    148119                }
    149                 if(allowCompression) {
    150                         return result;
    151                 }
    152                 return result;
    153         }
    154          
    155         public ASTNode parseDeclList() {
    156                 if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    157                         return syntaxErrorNode("DeclList² [IDENTIFIER¹]");
    158                 }
    159        
    160                 boolean allowCompression = true;
    161                 ASTNode result = new DeclListNode(nowReading);
    162                 result.setProductionTag(5);
    163                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    164                 {
    165                         ASTNode child = parseIdentifier();
    166                         result.appendChild(child);
    167                         allChildren.add(child);
    168                 }
    169                 while( nowReading.isLextant(Lextant.COMMA) ) {
    170                         expect(Lextant.COMMA);
    171                         {
    172                                 ASTNode child = parseIdentifier();
    173                                 result.appendChild(child);
    174                                 allChildren.add(child);
    175                         }
    176                 }
     120                expect(Lextant.TERMINATOR);
    177121                if(allowCompression) {
    178122                        return result;
     
    188132                boolean allowCompression = true;
    189133                ASTNode result = new FuncDefNode(nowReading);
    190                 result.setProductionTag(6);
     134                result.setProductionTag(4);
    191135                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    192136                expect(Lextant.FUNCTION);
     
    231175                boolean allowCompression = true;
    232176                ASTNode result = new ASTNode(nowReading);
    233                 result.setProductionTag(7);
     177                result.setProductionTag(5);
    234178                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    235179                {
     
    251195                boolean allowCompression = true;
    252196                ASTNode result = new ParameterListNode(nowReading);
    253                 result.setProductionTag(8);
     197                result.setProductionTag(6);
    254198                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    255199                {
     
    279223                boolean allowCompression = true;
    280224                ASTNode result = new ASTNode(nowReading);
    281                 result.setProductionTag(9);
     225                result.setProductionTag(7);
    282226                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    283227                {
     
    299243                boolean allowCompression = true;
    300244                ASTNode result = new ParameterNode(nowReading);
    301                 result.setProductionTag(10);
     245                result.setProductionTag(8);
    302246                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    303247                {
     
    324268                boolean allowCompression = true;
    325269                ASTNode result = new ASTNode(nowReading);
    326                 result.setProductionTag(11);
     270                result.setProductionTag(9);
    327271                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    328272                {
     
    344288                boolean allowCompression = true;
    345289                ASTNode result = new ASTNode(nowReading);
    346                 result.setProductionTag(12);
     290                result.setProductionTag(10);
    347291                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    348292                if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     
    397341                boolean allowCompression = true;
    398342                ASTNode result = new FuncCallOrAssignStmtNode(nowReading);
    399                 result.setProductionTag(13);
     343                result.setProductionTag(11);
    400344                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    401345                {
     
    436380                boolean allowCompression = true;
    437381                ASTNode result = new FuncCallNode(nowReading);
    438                 result.setProductionTag(14);
     382                result.setProductionTag(12);
    439383                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    440384                result.setToken(nowReading);
     
    455399                boolean allowCompression = true;
    456400                ASTNode result = new FuncCallArgListNode(nowReading);
    457                 result.setProductionTag(15);
     401                result.setProductionTag(13);
    458402                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    459403                if( nowReading.isLextant(Lextant.LROUND, Lextant.MINUS, Lextant.NOT) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    485429                boolean allowCompression = true;
    486430                ASTNode result = new AssignOperatorNode(nowReading);
    487                 result.setProductionTag(16);
     431                result.setProductionTag(14);
    488432                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    489433                if( nowReading.isLextant(Lextant.ASSIGN) ) {
     
    512456                boolean allowCompression = true;
    513457                ASTNode result = new AssignNode(nowReading);
    514                 result.setProductionTag(17);
     458                result.setProductionTag(15);
    515459                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    516460                {
     
    538482                boolean allowCompression = true;
    539483                ASTNode result = new IfStmtNode(nowReading);
    540                 result.setProductionTag(18);
     484                result.setProductionTag(16);
    541485                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    542486                expect(Lextant.IF);
     
    574518                boolean allowCompression = true;
    575519                ASTNode result = new WhileStmtNode(nowReading);
    576                 result.setProductionTag(19);
     520                result.setProductionTag(17);
    577521                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    578522                expect(Lextant.WHILE);
     
    602546                boolean allowCompression = true;
    603547                ASTNode result = new ReturnStmtNode(nowReading);
    604                 result.setProductionTag(20);
     548                result.setProductionTag(18);
    605549                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    606550                expect(Lextant.RETURN);
     
    626570                boolean allowCompression = true;
    627571                ASTNode result = new LocalVarDeclNode(nowReading);
    628                 result.setProductionTag(21);
     572                result.setProductionTag(19);
    629573                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    630574                expect(Lextant.VAR);
     
    665609                boolean allowCompression = true;
    666610                ASTNode result = new ASTNode(nowReading);
    667                 result.setProductionTag(22);
     611                result.setProductionTag(20);
    668612                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    669613                {
     
    685629                boolean allowCompression = true;
    686630                ASTNode result = new BlockStmtNode(nowReading);
    687                 result.setProductionTag(23);
     631                result.setProductionTag(21);
    688632                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    689633                expect(Lextant.LCURLY);
     
    709653                boolean allowCompression = true;
    710654                ASTNode result = new BinaryOperatorNode(nowReading);
    711                 result.setProductionTag(24);
     655                result.setProductionTag(22);
    712656                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    713657                {
     
    744688                boolean allowCompression = true;
    745689                ASTNode result = new BinaryOperatorNode(nowReading);
    746                 result.setProductionTag(25);
     690                result.setProductionTag(23);
    747691                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    748692                {
     
    773717                boolean allowCompression = true;
    774718                ASTNode result = new UnaryOperatorNode(nowReading);
    775                 result.setProductionTag(26);
     719                result.setProductionTag(24);
    776720                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    777721                if( nowReading.isLextant(Lextant.NOT) ) {
     
    799743                boolean allowCompression = true;
    800744                ASTNode result = new ASTNode(nowReading);
    801                 result.setProductionTag(27);
     745                result.setProductionTag(25);
    802746                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    803747                if( nowReading.isLextant(Lextant.LROUND) ) {
     
    846790                boolean allowCompression = true;
    847791                ASTNode result = new ASTNode(nowReading);
    848                 result.setProductionTag(28);
     792                result.setProductionTag(26);
    849793                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    850794                if( (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    875819                boolean allowCompression = true;
    876820                ASTNode result = new ASTNode(nowReading);
    877                 result.setProductionTag(29);
     821                result.setProductionTag(27);
    878822                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    879823                if( nowReading.isLextant(Lextant.MINUS) ) {
     
    915859                boolean allowCompression = true;
    916860                ASTNode result = new IntegerConstantNode(nowReading);
    917                 result.setProductionTag(30);
     861                result.setProductionTag(28);
    918862                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    919863                if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     
    941885                boolean allowCompression = true;
    942886                ASTNode result = new StringConstantNode(nowReading);
    943                 result.setProductionTag(31);
     887                result.setProductionTag(29);
    944888                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    945889                if( (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    968912                boolean allowCompression = true;
    969913                ASTNode result = new CompoundIdentifierNode(nowReading);
    970                 result.setProductionTag(32);
     914                result.setProductionTag(30);
    971915                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    972916                {
     
    997941                boolean allowCompression = true;
    998942                ASTNode result = new IdentifierNode(nowReading);
    999                 result.setProductionTag(33);
     943                result.setProductionTag(31);
    1000944                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1001945                if( !(nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     
    1016960                boolean allowCompression = true;
    1017961                ASTNode result = new ASTNode(nowReading);
    1018                 result.setProductionTag(34);
     962                result.setProductionTag(32);
    1019963                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1020964                if( nowReading.isLextant(Lextant.STREAM) ) {
     
    10591003                boolean allowCompression = true;
    10601004                ASTNode result = new StreamTypeNode(nowReading);
    1061                 result.setProductionTag(35);
     1005                result.setProductionTag(33);
    10621006                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10631007                expect(Lextant.STREAM);
     
    10841028                boolean allowCompression = true;
    10851029                ASTNode result = new FieldWidthNode(nowReading);
    1086                 result.setProductionTag(36);
     1030                result.setProductionTag(34);
    10871031                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10881032                if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     
    11031047                boolean allowCompression = true;
    11041048                ASTNode result = new ASTNode(nowReading);
    1105                 result.setProductionTag(37);
     1049                result.setProductionTag(35);
    11061050                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11071051                {
     
    11231067                boolean allowCompression = true;
    11241068                ASTNode result = new StructTypeNode(nowReading);
    1125                 result.setProductionTag(38);
     1069                result.setProductionTag(36);
    11261070                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11271071                expect(Lextant.STRUCT);
     
    11511095                boolean allowCompression = true;
    11521096                ASTNode result = new ASTNode(nowReading);
    1153                 result.setProductionTag(39);
     1097                result.setProductionTag(37);
    11541098                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11551099                {
     
    11711115                boolean allowCompression = true;
    11721116                ASTNode result = new StructTypeBodyNode(nowReading);
    1173                 result.setProductionTag(40);
     1117                result.setProductionTag(38);
    11741118                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11751119                expect(Lextant.LCURLY);
     
    12021146                boolean allowCompression = true;
    12031147                ASTNode result = new StructMemberNode(nowReading);
    1204                 result.setProductionTag(41);
     1148                result.setProductionTag(39);
    12051149                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12061150                {
     
    12271171                boolean allowCompression = true;
    12281172                ASTNode result = new ASTNode(nowReading);
    1229                 result.setProductionTag(42);
     1173                result.setProductionTag(40);
    12301174                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12311175                {
     
    12471191                boolean allowCompression = true;
    12481192                ASTNode result = new VoidNode(nowReading);
    1249                 result.setProductionTag(43);
     1193                result.setProductionTag(41);
    12501194                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12511195                expect(Lextant.VOID);
Note: See TracChangeset for help on using the changeset viewer.