Changeset 3261 for proto


Ignore:
Timestamp:
Jun 4, 2013, 2:05:00 PM (6 years ago)
Author:
ksherdy
Message:

Refactored Kernel init section.

Location:
proto/pabloj/trunk
Files:
3 added
3 deleted
12 edited
2 moved

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/input/grammar/scatter/pabloB.scatter

    r3257 r3261  
    3131  // t o k e n s
    3232  tokens {
    33         STATE,
     33        INIT,
    3434        KERNEL,
    3535        FUNCTION,       
     
    9090        // k e r n e l   d e c l a r a t i o n s                                                       
    9191        //
    92         kernelDef                       ->      KERNEL kernelName LCURLY stateDef funcDef (optFuncDef)? expr TERMINATOR RCURLY TERMINATOR? ; // KH: TODO - a temporary hack that appends a CarryDeclare node
     92        kernelDef                       ->      KERNEL kernelName LCURLY initDef funcDef (optFuncDef)? expr TERMINATOR RCURLY TERMINATOR? ; // KH: TODO - a temporary hack that appends a CarryDeclare node
    9393        kernelName                      #-> identifier ;
    9494       
    9595        //
    96         // k e r n e l   s t a t e 
     96        // k e r n e l   p r o p e r t i e s 
    9797        //
    98         stateDef                        #->  STATE LCURLY stateParameter* RCURLY TERMINATOR? ;
    99         stateParameter          ->  stateName ASSIGN stateValue TERMINATOR ;
    100         stateName                       #-> identifier ;
    101         stateValue                      ->      LSQUARE integerConstant (COMMA integerConstant)* RSQUARE ;
     98        initDef                         #->  INIT LCURLY kernelProperty* RCURLY TERMINATOR? ;
     99        kernelProperty          ->  propertyName ASSIGN propertyValue TERMINATOR ;
     100        propertyName            #-> identifier ;
     101        propertyValue           ->      LSQUARE integerConstant (COMMA integerConstant)* RSQUARE ;
    102102
    103103        //     
     
    116116        // c o d e   b l o c k  // (32,64,128,256,...)
    117117        //
    118         // codeBlock                    ->              CODEBLOCK codeBlockWidthSpecifier!      { @codeBlockWidth = @:stateValue; }
     118        // codeBlock                    ->              CODEBLOCK codeBlockWidthSpecifier!      { @codeBlockWidth = @:value; }
    119119        //                                                                                                                                      blockStmt (TERMINATOR)? ;
    120120        //                             
  • proto/pabloj/trunk/src/application/generators/ApplicationGenerator.java

    r3260 r3261  
    2222import java.io.File;
    2323import java.util.ArrayList;
     24import java.util.LinkedHashMap;
    2425import java.util.Map;
    2526
     
    2930import toolchain.pabloB.codeGenerator.visitors.Unparser;
    3031
     32import toolchain.pabloS.ast.Accessors;
    3133import toolchain.pabloS.transformer.visitors.PabloS2PabloBXFormer;
     34import toolchain.pabloS.transformer.visitors.StreamFunctionPropertySet;
     35import toolchain.pabloS.transformer.visitors.StreamFunctionPropertySetFactory;
    3236import toolchain.pabloS.transformer.visitors.StreamFunctions;
    33 import toolchain.pabloS.transformer.visitors.carry.CarryInfoSet;
    34 import toolchain.pabloS.transformer.visitors.carry.CarryInfoSetFactory;
    3537
    3638import application.config.Configuration;
     
    9799
    98100                        ArrayList<pabloS.ast.FuncDefNode> funcDefNodes = StreamFunctions.makeList(pabloSAST);
    99                         Map<String, CarryInfoSet> carryInfoSetMap = CarryInfoSetFactory.makeCarryInfoSetMap(funcDefNodes); 
     101                        Map<String, StreamFunctionPropertySet> streamFunctionPropertySetMap = new LinkedHashMap<String, StreamFunctionPropertySet>();
    100102                       
    101                         PabloS2PabloBXFormer pabloS2PabloBXFormer = new PabloS2PabloBXFormer(carryInfoSetMap, carrySetEncoder);
     103                        for(pabloS.ast.FuncDefNode funcDefNode : funcDefNodes) {
     104                            StreamFunctionPropertySet value = StreamFunctionPropertySetFactory.apply(funcDefNode);
     105                            String key = Accessors.funcName(funcDefNode);
     106                            streamFunctionPropertySetMap.put(key, value);
     107                        }
     108                       
     109                        PabloS2PabloBXFormer pabloS2PabloBXFormer = new PabloS2PabloBXFormer(streamFunctionPropertySetMap, carrySetEncoder);
    102110                        pabloBAST = pabloS2PabloBXFormer.XForm(decoratedTree, optDecoratedTree);
    103111                       
  • proto/pabloj/trunk/src/pabloB/ast/ASTTransformer.java

    r3258 r3261  
    5050        public ASTNode visit(IfStmtNode node);
    5151
     52        public ASTNode visit(InitDefNode node);
     53
    5254        public ASTNode visit(IntTypeNode node);
    5355
     
    5658        public ASTNode visit(KernelDefNode node);
    5759
     60        public ASTNode visit(KernelPropertyNode node);
     61
    5862        public ASTNode visit(LocalVarDeclNode node);
    5963
     
    6468        public ASTNode visit(ProgramNode node);
    6569
     70        public ASTNode visit(PropertyValueNode node);
     71
    6672        public ASTNode visit(ReturnStmtNode node);
    67 
    68         public ASTNode visit(StateDefNode node);
    69 
    70         public ASTNode visit(StateParameterNode node);
    71 
    72         public ASTNode visit(StateValueNode node);
    7373
    7474        public ASTNode visit(StringConstantNode node);
     
    173173                }
    174174
     175                public ASTNode visit(InitDefNode node) {
     176                        return defaultVisit(node);
     177                }
     178
    175179                public ASTNode visit(IntTypeNode node) {
    176180                        return defaultVisit(node);
     
    185189                }
    186190
     191                public ASTNode visit(KernelPropertyNode node) {
     192                        return defaultVisit(node);
     193                }
     194
    187195                public ASTNode visit(LocalVarDeclNode node) {
    188196                        return defaultVisit(node);
     
    201209                }
    202210
     211                public ASTNode visit(PropertyValueNode node) {
     212                        return defaultVisit(node);
     213                }
     214
    203215                public ASTNode visit(ReturnStmtNode node) {
    204                         return defaultVisit(node);
    205                 }
    206 
    207                 public ASTNode visit(StateDefNode node) {
    208                         return defaultVisit(node);
    209                 }
    210 
    211                 public ASTNode visit(StateParameterNode node) {
    212                         return defaultVisit(node);
    213                 }
    214 
    215                 public ASTNode visit(StateValueNode node) {
    216216                        return defaultVisit(node);
    217217                }
  • proto/pabloj/trunk/src/pabloB/ast/ASTVisitor.java

    r3258 r3261  
    7171        public T visitLeave(IfStmtNode node, List<T> childResults);
    7272
     73        public void visitEnter(InitDefNode node);
     74        public T visitLeave(InitDefNode node, List<T> childResults);
     75
    7376        public void visitEnter(IntTypeNode node);
    7477        public T visitLeave(IntTypeNode node, List<T> childResults);
     
    8083        public T visitLeave(KernelDefNode node, List<T> childResults);
    8184
     85        public void visitEnter(KernelPropertyNode node);
     86        public T visitLeave(KernelPropertyNode node, List<T> childResults);
     87
    8288        public void visitEnter(LocalVarDeclNode node);
    8389        public T visitLeave(LocalVarDeclNode node, List<T> childResults);
     
    9298        public T visitLeave(ProgramNode node, List<T> childResults);
    9399
     100        public void visitEnter(PropertyValueNode node);
     101        public T visitLeave(PropertyValueNode node, List<T> childResults);
     102
    94103        public void visitEnter(ReturnStmtNode node);
    95104        public T visitLeave(ReturnStmtNode node, List<T> childResults);
    96 
    97         public void visitEnter(StateDefNode node);
    98         public T visitLeave(StateDefNode node, List<T> childResults);
    99 
    100         public void visitEnter(StateParameterNode node);
    101         public T visitLeave(StateParameterNode node, List<T> childResults);
    102 
    103         public void visitEnter(StateValueNode node);
    104         public T visitLeave(StateValueNode node, List<T> childResults);
    105105
    106106        public void visitEnter(StringConstantNode node);
     
    282282                }
    283283
     284                public void visitEnter(InitDefNode node) {
     285                        defaultVisitEnter(node);
     286                }
     287                public T visitLeave(InitDefNode node, List<T> childResults) {
     288                        return defaultVisitLeave(node, childResults);
     289                }
     290
    284291                public void visitEnter(IntTypeNode node) {
    285292                        defaultVisitEnter(node);
     
    303310                }
    304311
     312                public void visitEnter(KernelPropertyNode node) {
     313                        defaultVisitEnter(node);
     314                }
     315                public T visitLeave(KernelPropertyNode node, List<T> childResults) {
     316                        return defaultVisitLeave(node, childResults);
     317                }
     318
    305319                public void visitEnter(LocalVarDeclNode node) {
    306320                        defaultVisitEnter(node);
     
    331345                }
    332346
     347                public void visitEnter(PropertyValueNode node) {
     348                        defaultVisitEnter(node);
     349                }
     350                public T visitLeave(PropertyValueNode node, List<T> childResults) {
     351                        return defaultVisitLeave(node, childResults);
     352                }
     353
    333354                public void visitEnter(ReturnStmtNode node) {
    334355                        defaultVisitEnter(node);
    335356                }
    336357                public T visitLeave(ReturnStmtNode node, List<T> childResults) {
    337                         return defaultVisitLeave(node, childResults);
    338                 }
    339 
    340                 public void visitEnter(StateDefNode node) {
    341                         defaultVisitEnter(node);
    342                 }
    343                 public T visitLeave(StateDefNode node, List<T> childResults) {
    344                         return defaultVisitLeave(node, childResults);
    345                 }
    346 
    347                 public void visitEnter(StateParameterNode node) {
    348                         defaultVisitEnter(node);
    349                 }
    350                 public T visitLeave(StateParameterNode node, List<T> childResults) {
    351                         return defaultVisitLeave(node, childResults);
    352                 }
    353 
    354                 public void visitEnter(StateValueNode node) {
    355                         defaultVisitEnter(node);
    356                 }
    357                 public T visitLeave(StateValueNode node, List<T> childResults) {
    358358                        return defaultVisitLeave(node, childResults);
    359359                }
  • proto/pabloj/trunk/src/pabloB/ast/SimpleVisitor.java

    r3258 r3261  
    5151        public void visit(IfStmtNode node);
    5252
     53        public void visit(InitDefNode node);
     54
    5355        public void visit(IntTypeNode node);
    5456
     
    5759        public void visit(KernelDefNode node);
    5860
     61        public void visit(KernelPropertyNode node);
     62
    5963        public void visit(LocalVarDeclNode node);
    6064
     
    6569        public void visit(ProgramNode node);
    6670
     71        public void visit(PropertyValueNode node);
     72
    6773        public void visit(ReturnStmtNode node);
    68 
    69         public void visit(StateDefNode node);
    70 
    71         public void visit(StateParameterNode node);
    72 
    73         public void visit(StateValueNode node);
    7474
    7575        public void visit(StringConstantNode node);
     
    174174                }
    175175
     176                public void visit(InitDefNode node) {
     177                        defaultVisit(node);
     178                }
     179
    176180                public void visit(IntTypeNode node) {
    177181                        defaultVisit(node);
     
    186190                }
    187191
     192                public void visit(KernelPropertyNode node) {
     193                        defaultVisit(node);
     194                }
     195
    188196                public void visit(LocalVarDeclNode node) {
    189197                        defaultVisit(node);
     
    202210                }
    203211
     212                public void visit(PropertyValueNode node) {
     213                        defaultVisit(node);
     214                }
     215
    204216                public void visit(ReturnStmtNode node) {
    205                         defaultVisit(node);
    206                 }
    207 
    208                 public void visit(StateDefNode node) {
    209                         defaultVisit(node);
    210                 }
    211 
    212                 public void visit(StateParameterNode node) {
    213                         defaultVisit(node);
    214                 }
    215 
    216                 public void visit(StateValueNode node) {
    217217                        defaultVisit(node);
    218218                }
  • proto/pabloj/trunk/src/pabloB/ast/VoidVisitor.java

    r3258 r3261  
    6969        public void visitLeave(IfStmtNode node);
    7070
     71        public void visitEnter(InitDefNode node);
     72        public void visitLeave(InitDefNode node);
     73
    7174        public void visitEnter(IntTypeNode node);
    7275        public void visitLeave(IntTypeNode node);
     
    7881        public void visitLeave(KernelDefNode node);
    7982
     83        public void visitEnter(KernelPropertyNode node);
     84        public void visitLeave(KernelPropertyNode node);
     85
    8086        public void visitEnter(LocalVarDeclNode node);
    8187        public void visitLeave(LocalVarDeclNode node);
     
    9096        public void visitLeave(ProgramNode node);
    9197
     98        public void visitEnter(PropertyValueNode node);
     99        public void visitLeave(PropertyValueNode node);
     100
    92101        public void visitEnter(ReturnStmtNode node);
    93102        public void visitLeave(ReturnStmtNode node);
    94 
    95         public void visitEnter(StateDefNode node);
    96         public void visitLeave(StateDefNode node);
    97 
    98         public void visitEnter(StateParameterNode node);
    99         public void visitLeave(StateParameterNode node);
    100 
    101         public void visitEnter(StateValueNode node);
    102         public void visitLeave(StateValueNode node);
    103103
    104104        public void visitEnter(StringConstantNode node);
     
    279279                }
    280280
     281                public void visitEnter(InitDefNode node) {
     282                        defaultVisitEnter(node);
     283                }
     284                public void visitLeave(InitDefNode node) {
     285                        defaultVisitLeave(node);
     286                }
     287
    281288                public void visitEnter(IntTypeNode node) {
    282289                        defaultVisitEnter(node);
     
    300307                }
    301308
     309                public void visitEnter(KernelPropertyNode node) {
     310                        defaultVisitEnter(node);
     311                }
     312                public void visitLeave(KernelPropertyNode node) {
     313                        defaultVisitLeave(node);
     314                }
     315
    302316                public void visitEnter(LocalVarDeclNode node) {
    303317                        defaultVisitEnter(node);
     
    328342                }
    329343
     344                public void visitEnter(PropertyValueNode node) {
     345                        defaultVisitEnter(node);
     346                }
     347                public void visitLeave(PropertyValueNode node) {
     348                        defaultVisitLeave(node);
     349                }
     350
    330351                public void visitEnter(ReturnStmtNode node) {
    331352                        defaultVisitEnter(node);
    332353                }
    333354                public void visitLeave(ReturnStmtNode node) {
    334                         defaultVisitLeave(node);
    335                 }
    336 
    337                 public void visitEnter(StateDefNode node) {
    338                         defaultVisitEnter(node);
    339                 }
    340                 public void visitLeave(StateDefNode node) {
    341                         defaultVisitLeave(node);
    342                 }
    343 
    344                 public void visitEnter(StateParameterNode node) {
    345                         defaultVisitEnter(node);
    346                 }
    347                 public void visitLeave(StateParameterNode node) {
    348                         defaultVisitLeave(node);
    349                 }
    350 
    351                 public void visitEnter(StateValueNode node) {
    352                         defaultVisitEnter(node);
    353                 }
    354                 public void visitLeave(StateValueNode node) {
    355355                        defaultVisitLeave(node);
    356356                }
  • proto/pabloj/trunk/src/pabloB/lexicalAnalyzer/Lextant.java

    r3257 r3261  
    2323        BITFIELD("BitField", "main"),
    2424        RSQUARE("]", "main"),
     25        INIT("init", "main"),
    2526        LANGLE("<", "main"),
    2627        BITBLOCK("BitBlock", "main"),
     
    4041        RCURLY("}", "main"),
    4142        RANGLE(">", "main"),
    42         STATE("state", "main"),
    4343        KERNEL("kernel", "main"),
    4444        COMMA(",", "main"),
  • proto/pabloj/trunk/src/pabloB/parser/Parser.java

    r3258 r3261  
    222222                expect(Lextant.LCURLY);
    223223                {
    224                         ASTNode child = parseStateDef();
     224                        ASTNode child = parseInitDef();
    225225                        result.appendChild(child);
    226226                        allChildren.add(child);
     
    274274        }
    275275         
    276         public ASTNode parseStateDef() {
    277                 if( !(nowReading.isLextant(Lextant.STATE)) ) {
    278                         return syntaxErrorNode("stateDef² [STATE¹]");
    279                 }
    280        
    281                 boolean allowCompression = true;
    282                 ASTNode result = new StateDefNode(nowReading);
     276        public ASTNode parseInitDef() {
     277                if( !(nowReading.isLextant(Lextant.INIT)) ) {
     278                        return syntaxErrorNode("initDef² [INIT¹]");
     279                }
     280       
     281                boolean allowCompression = true;
     282                ASTNode result = new InitDefNode(nowReading);
    283283                result.setProductionTag(9);
    284284                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    285                 expect(Lextant.STATE);
     285                expect(Lextant.INIT);
    286286                expect(Lextant.LCURLY);
    287287                while( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    288288                        {
    289                                 ASTNode child = parseStateParameter();
     289                                ASTNode child = parseKernelProperty();
    290290                                result.appendChild(child);
    291291                                allChildren.add(child);
     
    302302        }
    303303         
    304         public ASTNode parseStateParameter() {
     304        public ASTNode parseKernelProperty() {
    305305                if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    306                         return syntaxErrorNode("stateParameter² [IDENTIFIER¹]");
    307                 }
    308        
    309                 boolean allowCompression = true;
    310                 ASTNode result = new StateParameterNode(nowReading);
     306                        return syntaxErrorNode("kernelProperty² [IDENTIFIER¹]");
     307                }
     308       
     309                boolean allowCompression = true;
     310                ASTNode result = new KernelPropertyNode(nowReading);
    311311                result.setProductionTag(10);
    312312                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    313313                {
    314                         ASTNode child = parseStateName();
     314                        ASTNode child = parsePropertyName();
    315315                        result.appendChild(child);
    316316                        allChildren.add(child);
     
    318318                expect(Lextant.ASSIGN);
    319319                {
    320                         ASTNode child = parseStateValue();
     320                        ASTNode child = parsePropertyValue();
    321321                        result.appendChild(child);
    322322                        allChildren.add(child);
     
    329329        }
    330330         
    331         public ASTNode parseStateName() {
     331        public ASTNode parsePropertyName() {
    332332                if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    333                         return syntaxErrorNode("stateName² [IDENTIFIER¹]");
     333                        return syntaxErrorNode("propertyName² [IDENTIFIER¹]");
    334334                }
    335335       
     
    349349        }
    350350         
    351         public ASTNode parseStateValue() {
     351        public ASTNode parsePropertyValue() {
    352352                if( !(nowReading.isLextant(Lextant.LSQUARE)) ) {
    353                         return syntaxErrorNode("stateValue² [LSQUARE¹]");
    354                 }
    355        
    356                 boolean allowCompression = true;
    357                 ASTNode result = new StateValueNode(nowReading);
     353                        return syntaxErrorNode("propertyValue² [LSQUARE¹]");
     354                }
     355       
     356                boolean allowCompression = true;
     357                ASTNode result = new PropertyValueNode(nowReading);
    358358                result.setProductionTag(12);
    359359                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Generators.java

    r3260 r3261  
    2121        // PabloS2PabloB Token Conversion 
    2222        ////////////////////////////////////////////////////////////////////////////
    23        
    2423        public static final String LEXICAL_CONTEXT = "main";   
    2524       
     
    101100        // PabloB Nodes
    102101        ////////////////////////////////////////////////////////////////////////////   
    103        
    104102        public static KernelDefNode makeKernelDef(String identifier,
    105                         StateDefNode stateDefNode,
     103                        InitDefNode stateDefNode,
    106104                        FuncDefNode funcDefNode,
    107105                        FuncDefNode optFuncDefNode,
     
    124122        }       
    125123
    126     // stateDef            #->  STATE LCURLY stateParameter* RCURLY TERMINATOR? ;
    127     public static StateDefNode makeStateDefNode (Locator locator) {
    128         StateDefNode stateDef = new StateDefNode(Generators.makeLextantToken(Lextant.LCURLY, locator));
     124    public static InitDefNode makeInitDefNode (Locator locator) {
     125        InitDefNode stateDef = new InitDefNode(Generators.makeLextantToken(Lextant.LCURLY, locator));
    129126        return stateDef;
    130127    }
    131128       
    132         public static StateDefNode makeStateDefNode (List<StateParameterNode> stateParameters, Locator locator) {
    133                 StateDefNode stateDef = new StateDefNode(Generators.makeLextantToken(Lextant.LCURLY, locator));
    134                 for(StateParameterNode stateParameter : stateParameters) {
     129        public static InitDefNode makeInitDefNode (List<KernelPropertyNode> stateParameters, Locator locator) {
     130                InitDefNode stateDef = new InitDefNode(Generators.makeLextantToken(Lextant.LCURLY, locator));
     131                for(KernelPropertyNode stateParameter : stateParameters) {
    135132                    stateDef.appendChild(stateParameter);
    136133                }
    137134                return stateDef;
    138135        }
    139        
    140         // stateParameter      ->  stateName ASSIGN stateValue TERMINATOR ;
    141         public static StateParameterNode makeStateParameterNode (IdentifierNode stateName, StateValueNode stateValue) {
    142             StateParameterNode stateParameter = new StateParameterNode(stateName.getToken());
    143             stateParameter.appendChild(stateName);
    144             stateParameter.appendChild(stateValue);
     136
     137        public static KernelPropertyNode makeKernelPropertyNode (IdentifierNode propertyName, PropertyValueNode propertyValue) {
     138            KernelPropertyNode stateParameter = new KernelPropertyNode(propertyName.getToken());
     139            stateParameter.appendChild(propertyName);
     140            stateParameter.appendChild(propertyValue);
    145141            return stateParameter;
    146142        }
    147143   
    148         // stateValue          ->  LSQUARE integerConstant (COMMA integerConstant)* RSQUARE ;
    149         public static StateValueNode makeStateValueNode(List<Integer> values, Locator locator) {
    150             StateValueNode stateValue = new StateValueNode(Generators.makeLextantToken(Lextant.LSQUARE, locator));
     144        public static PropertyValueNode makePropertyValueNode(List<Integer> values, Locator locator) {
     145            PropertyValueNode stateValue = new PropertyValueNode(Generators.makeLextantToken(Lextant.LSQUARE, locator));
    151146        for(Integer i : values) {
    152147            IntegerConstantNode n = Generators.makeIntegerConstantNode(i, locator);
     
    156151        }
    157152       
    158         // stateValue helper
    159         public static StateValueNode makeStateValueNode(Integer value, Locator locator) {
     153        public static PropertyValueNode makePropertyValueNode(Integer value, Locator locator) {
    160154                List<Integer> values = new ArrayList<Integer>();
    161155                values.add(value);
    162                 return Generators.makeStateValueNode(values, locator);
     156                return Generators.makePropertyValueNode(values, locator);
    163157        }       
    164158       
  • proto/pabloj/trunk/src/toolchain/pabloB/codeGenerator/visitors/Unparser.java

    r3260 r3261  
    128128        ////////////////////////////////////////////////////////////////////////////
    129129
    130         public CodeStore visitLeave(StateDefNode node, List<CodeStore> childResults) {
     130        public CodeStore visitLeave(InitDefNode node, List<CodeStore> childResults) {
    131131                CodeStore code = new CodeStore();
    132132               
     
    142142        }
    143143
    144         public CodeStore visitLeave(StateParameterNode node, List<CodeStore> childResults) {
     144        public CodeStore visitLeave(KernelPropertyNode node, List<CodeStore> childResults) {
    145145                CodeStore code = new CodeStore();               
    146146                return code;
    147147        }
    148148
    149         public CodeStore visitLeave(StateValueNode node, List<CodeStore> childResults) {
     149        public CodeStore visitLeave(PropertyValueNode node, List<CodeStore> childResults) {
    150150                CodeStore code = new CodeStore();               
    151151                return code;
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/PabloS2PabloBXFormer.java

    r3260 r3261  
    2121import toolchain.pabloB.lang.carrySet.CarrySetEncoder;
    2222import toolchain.pabloS.lang.BuiltinCallUtil;
    23 import toolchain.pabloS.transformer.visitors.carry.CarryInfoSet;
    2423
    2524public class PabloS2PabloBXFormer {
     
    3433        private pabloS.ast.ASTNode optDecoratedASTTree;                 
    3534       
    36         private Map<String, CarryInfoSet> carryInfoSetMap;
     35        private Map<String, StreamFunctionPropertySet> streamFunctionPropertySetMap;
    3736        private CarrySetEncoder carrySetEncoder;
    3837 
    39     public PabloS2PabloBXFormer(Map<String, CarryInfoSet> carryInfoSetMap, CarrySetEncoder carrySetEncoder) {
     38    public PabloS2PabloBXFormer(Map<String, StreamFunctionPropertySet> streamFunctionPropertySetMap, CarrySetEncoder carrySetEncoder) {
    4039        this.decoratedASTTree = null;
    4140        this.optDecoratedASTTree = null;
    42         this.carryInfoSetMap = carryInfoSetMap;
     41        this.streamFunctionPropertySetMap = streamFunctionPropertySetMap;
    4342        this.carrySetEncoder = carrySetEncoder;
    4443    }
     
    6968                       
    7069                        String kernelName = entry.getKey();                     
    71                         CarryInfoSet carryInfoSetSymbol = carryInfoSetMap.get(kernelName);
     70                        StreamFunctionPropertySet streamFunctionPropertySet = this.streamFunctionPropertySetMap.get(kernelName);
    7271                       
    7372                        ////////////////////////////////////////////////////////////
    7473                        // Kernel state parameters
    7574                        ////////////////////////////////////////////////////////////
    76                         StateDefNode stateDefNode = Generators.makeStateDefNode(funcDefNode);                   
     75                        InitDefNode stateDefNode = Generators.makeInitDefNode(funcDefNode);                     
    7776                       
    7877                        ////////////////////////////////////////////////////////////
    7978                        // Carry1
    80                 IdentifierNode stateName                = Generators.makeIdentifierNode(KernelState.CARRY1_LIST.name(), locator);
    81                 StateValueNode stateValue               = Generators.makeStateValueNode(carryInfoSetSymbol.Carry1List(), locator);
    82                         StateParameterNode stateParameter       = Generators.makeStateParameterNode(stateName, stateValue);
    83                         stateDefNode.appendChild(stateParameter);
     79                IdentifierNode propertyName             = Generators.makeIdentifierNode(KernelState.CARRY1_LIST.name(), locator);
     80                PropertyValueNode propertyValue         = Generators.makePropertyValueNode(streamFunctionPropertySet.getCarry1InitValues(), locator);
     81                        KernelPropertyNode property         = Generators.makeKernelPropertyNode(propertyName, propertyValue);
     82                        stateDefNode.appendChild(property);
    8483                       
    8584                        ////////////////////////////////////////////////////////////
    8685                        // Carry1 Count
    87                 stateName       = Generators.makeIdentifierNode(KernelState.CARRY1_COUNT.name(), locator);
    88                 stateValue      = Generators.makeStateValueNode(carryInfoSetSymbol.Carry1Count(), locator);
    89                         stateParameter  = Generators.makeStateParameterNode(stateName, stateValue);
    90                         stateDefNode.appendChild(stateParameter);
     86                propertyName            = Generators.makeIdentifierNode(KernelState.CARRY1_COUNT.name(), locator);
     87                propertyValue           = Generators.makePropertyValueNode(streamFunctionPropertySet.Carry1Count(), locator);
     88                        property                = Generators.makeKernelPropertyNode(propertyName, propertyValue);
     89                        stateDefNode.appendChild(property);
    9190
    9291                        ////////////////////////////////////////////////////////////                   
    9392                        // Add CarryFlip call for variable initialization                       
    9493                       
    95                         for(Integer i : carryInfoSetSymbol.Carry1List()) {
     94                        for(Integer i : streamFunctionPropertySet.getCarry1InitValues()) {
    9695
    9796                                if(i > 0) {
     
    123122                       
    124123                        ////////////////////////////////////////////////////////////
    125                         // CarryN
    126                 stateName       = Generators.makeIdentifierNode(KernelState.CARRYN_LIST.name(), locator);
    127                 stateValue      = Generators.makeStateValueNode(carryInfoSetSymbol.CarryNList(), locator);
    128                         stateParameter  = Generators.makeStateParameterNode(stateName, stateValue);
    129                         stateDefNode.appendChild(stateParameter);
    130 
    131                         ////////////////////////////////////////////////////////////
    132                         // CarryN Count                 
    133                 stateName       = Generators.makeIdentifierNode(KernelState.CARRYN_COUNT.name(), locator);
    134                 stateValue      = Generators.makeStateValueNode(carryInfoSetSymbol.CarryNCount(), locator);
    135                         stateParameter  = Generators.makeStateParameterNode(stateName, stateValue);
    136                         stateDefNode.appendChild(stateParameter);
     124                        // CarryN 
     125                propertyName       = Generators.makeIdentifierNode(KernelState.CARRYN_LIST.name(), locator);
     126                propertyValue      = Generators.makePropertyValueNode(streamFunctionPropertySet.getCarryNInitValues(), locator);
     127                        property           = Generators.makeKernelPropertyNode(propertyName, propertyValue);
     128                        stateDefNode.appendChild(property);
     129
     130                        ////////////////////////////////////////////////////////////
     131                        // CarryN count                        
     132                propertyName       = Generators.makeIdentifierNode(KernelState.CARRYN_COUNT.name(), locator);
     133                propertyValue      = Generators.makePropertyValueNode(streamFunctionPropertySet.CarryNCount(), locator);
     134                        property           = Generators.makeKernelPropertyNode(propertyName, propertyValue);
     135                        stateDefNode.appendChild(property);
    137136                       
    138137                        ////////////////////////////////////////////////////////////
    139138                        // KH: TODO - LookAhead
    140                 stateName       = Generators.makeIdentifierNode(KernelState.LOOK_AHEAD.name(), locator);
    141                 stateValue      = Generators.makeStateValueNode(0, locator);
    142                         stateParameter  = Generators.makeStateParameterNode(stateName, stateValue);
    143                         stateDefNode.appendChild(stateParameter);
     139                propertyName       = Generators.makeIdentifierNode(KernelState.LOOK_AHEAD.name(), locator);
     140                propertyValue      = Generators.makePropertyValueNode(0, locator);
     141                        property           = Generators.makeKernelPropertyNode(propertyName, propertyValue);
     142                        stateDefNode.appendChild(property);
    144143                       
    145144                        ////////////////////////////////////////////////////////////
    146145                        // KH: TODO - LookBehind
    147                 stateName       = Generators.makeIdentifierNode(KernelState.LOOK_BEHIND.name(), locator);
    148                 stateValue      = Generators.makeStateValueNode(0, locator);
    149                         stateParameter  = Generators.makeStateParameterNode(stateName, stateValue);
    150                         stateDefNode.appendChild(stateParameter);
     146                propertyName            = Generators.makeIdentifierNode(KernelState.LOOK_BEHIND.name(), locator);
     147                propertyValue           = Generators.makePropertyValueNode(0, locator);
     148                        property        = Generators.makeKernelPropertyNode(propertyName, propertyValue);
     149                        stateDefNode.appendChild(property);
    151150                       
    152151                        pabloB.ast.KernelDefNode kernelDefNode =
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/StreamFunctionPropertySet.java

    r3260 r3261  
    11/*
    2  * Carry Information Symbol
     2 * Container for stream function properties.
    33 *
    44 * @author Ken Herdy <ksherdy at sfu dot ca>
    55 */
    6 package toolchain.pabloS.transformer.visitors.carry;
     6package toolchain.pabloS.transformer.visitors;
    77
    88import java.util.ArrayList;
    99
    10 public class CarryInfoSet {
     10public class StreamFunctionPropertySet {
    1111
    12         private ArrayList<Integer> carry1 = null;
    13         private ArrayList<Integer> carryN = null;
     12        private ArrayList<Integer> carry1;
     13        private ArrayList<Integer> carryN;
     14        private int lookAhead;
     15        private int lookBehind;
    1416       
    15         public CarryInfoSet () {
    16                 carry1 = new ArrayList<Integer>();
    17                 carryN = new ArrayList<Integer>();
     17        public StreamFunctionPropertySet () {
     18                carry1        = new ArrayList<Integer>();
     19                carryN        = new ArrayList<Integer>();
     20                setLookAhead(0);
     21                setLookBehind(0);
    1822        }
    1923       
     
    2630        }       
    2731       
    28         public void addCarry1(Integer value) {
    29                 carry1.add(value);
    30         }
    31 
    32         public void addCarryN(Integer value) {
    33                 carryN.add(value);
    34         }       
    35 
    36         public ArrayList<Integer> Carry1List() {
     32        public ArrayList<Integer> getCarry1InitValues() {
    3733                return carry1;
    3834        }
    3935
    40         public ArrayList<Integer> CarryNList() {
     36        public ArrayList<Integer> getCarryNInitValues() {
    4137                return carryN;
    4238        }
    4339
     40    public void addNextCarry1InitValue(Integer value) {
     41        carry1.add(value);
     42    }
     43
     44    public void addNextCarryNInitValue(Integer value) {
     45        carryN.add(value);
     46    }
     47
     48    private int getLookAhead() {
     49        return lookAhead;
     50    }
     51
     52    private void setLookAhead(int lookAhead) {
     53        this.lookAhead = lookAhead;
     54    }
     55
     56    private int getLookBehind() {
     57        return lookBehind;
     58    }
     59
     60    private void setLookBehind(int lookBehind) {
     61        this.lookBehind = lookBehind;
     62    }           
     63       
    4464}
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/StreamFunctionPropertySetFactory.java

    r3260 r3261  
    11/*
     2 * Constructs a stream function property set.
    23 *
    34 * @author Ken Herdy <ksherdy at sfu dot ca>
    45 */
    5 package toolchain.pabloS.transformer.visitors.carry;
    6 
    7 import java.util.List;
    8 import java.util.Map;
    9 import java.util.LinkedHashMap;
     6package toolchain.pabloS.transformer.visitors;
    107
    118import pabloS.ast.*;
    12 import toolchain.pabloS.ast.Accessors;
    139import toolchain.pabloS.lang.BuiltinCallUtil;
    1410
    15 public class CarryInfoSetFactory {     
    16            
    17     public static Map<java.lang.String, CarryInfoSet> makeCarryInfoSetMap(List<pabloS.ast.FuncDefNode> funcDefs) {
     11public class StreamFunctionPropertySetFactory {
     12       
     13    static public StreamFunctionPropertySet apply(FuncDefNode node) {
     14        StreamFunctionPropertySetVisitor visitor = new StreamFunctionPropertySetVisitor();
     15        node.accept(visitor);
     16        return visitor.propertySet();
     17    }   
     18   
     19    static private class StreamFunctionPropertySetVisitor extends VoidVisitor.Default {
    1820       
    19         Map<java.lang.String,CarryInfoSet> map = new LinkedHashMap<java.lang.String, CarryInfoSet>();
     21        private StreamFunctionPropertySet propertySet = new StreamFunctionPropertySet();
    2022       
    21         for(pabloS.ast.FuncDefNode funcDef : funcDefs) {
    22                 CarryInfoSetVisitor visitor = new CarryInfoSetVisitor();
    23                 funcDef.accept(visitor);
    24                 map.put(Accessors.funcName(funcDef), visitor.carryInfoSet);
     23        public StreamFunctionPropertySet propertySet() {
     24            return propertySet;
    2525        }
    26            
    27         return map;
     26       
     27        public void visitLeave(FuncCallNode node) {
     28               
     29                if(BuiltinCallUtil.isCarry1(node)) {
     30                        int initializer = BuiltinCallUtil.builtin(node).intInitialValue();
     31                        propertySet.addNextCarry1InitValue(initializer);
     32                }
     33               
     34                if(BuiltinCallUtil.isCarryN(node)) {
     35                        //int initializer = BuiltinCallUtil.builtin(node).intInitialValue();
     36                        propertySet.addNextCarryNInitValue(0);
     37                }
     38               
     39                // KH: TODO - Add logic for LookAhead, LookBehind ...
     40        }
    2841    }
    29    
    30         static private class CarryInfoSetVisitor extends VoidVisitor.Default {
    31        
    32                 private CarryInfoSet carryInfoSet = new CarryInfoSet();
    33                
    34                 public void visitLeave(FuncCallNode node) {
    35                        
    36                         if(BuiltinCallUtil.isCarry1(node)) {
    37                                 int initializer = BuiltinCallUtil.builtin(node).intInitialValue();
    38                                 carryInfoSet.addCarry1(initializer);
    39                         }
    40                        
    41                         if(BuiltinCallUtil.isCarryN(node)) {
    42                                 //int initializer = BuiltinCallUtil.builtin(node).intInitialValue();
    43                                 carryInfoSet.addCarryN(0);
    44                         }
    45                 }
    46         }
    4742}
     43
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/StreamFunctions.java

    r3249 r3261  
    11/*
    2  * Gathers PabloS stream function definitions as an ArrayList of FuncDefNodes.
     2 * Lists PabloS stream function definition nodes.
    33 *
    44 * @author Ken Herdy <ksherdy at sfu dot ca>
     
    2626                public void visitLeave(FuncDefNode node) {
    2727                        list.add(node);                                 
    28                        
    2928                }               
    3029        }
Note: See TracChangeset for help on using the changeset viewer.