Changeset 3257 for proto/pabloj


Ignore:
Timestamp:
Jun 3, 2013, 5:57:23 PM (6 years ago)
Author:
ksherdy
Message:

PabloB kernel state def (partial impl.).

Location:
proto/pabloj/trunk
Files:
5 added
12 edited

Legend:

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

    r3192 r3257  
    77//                      29-03-2013      Added IDISA function call.
    88//                              06-04-2013      Updated to Scatter with types.
    9 //
    10 // TODO:                CodeBlock, types ...
    119//
    1210
     
    3331  // t o k e n s
    3432  tokens {
    35         INIT,
     33        STATE,
    3634        KERNEL,
    3735        FUNCTION,       
     
    9290        // k e r n e l   d e c l a r a t i o n s                                                       
    9391        //
    94         kernelDef                       ->      KERNEL kernelName LCURLY initDef funcDef (optFuncDef)? expr TERMINATOR RCURLY TERMINATOR? ; // TODO - hack - stick CarryDeclare at end for now
     92        kernelDef                       ->      KERNEL kernelName LCURLY stateDef funcDef (optFuncDef)? expr TERMINATOR RCURLY TERMINATOR? ; // KH: TODO - a temporary hack that appends a CarryDeclare node
    9593        kernelName                      #-> identifier ;
    9694       
    9795        //
    98         // k e r n e l   s t a t e   i n i t
     96        // k e r n e l   s t a t e 
    9997        //
    100         initDef                         ->  INIT initBlock TERMINATOR? ;
    101         initBlock                       #-> LCURLY (stateInitStmt)* RCURLY;
    102         stateInitStmt           ->  stateIdentifier LSQUARE stateSize RSQUARE ASSIGN LCURLY stateInitList RCURLY TERMINATOR?; // TODO - array node
    103         stateIdentifier         ->  IDENTIFIER ;
    104         stateSize                       ->  integerConstant ;
    105         stateInitList           ->      integerConstant (COMMA integerConstant)* ; // a carry constant of uintN type, TODO - array init list
    106         stateValue                      ->  integerConstant ;
     98        stateDef                        #->  STATE LCURLY stateParameter* RCURLY TERMINATOR? ;
     99        stateParameter          ->  stateName ASSIGN stateValue TERMINATOR ;
     100        stateName                       #-> identifier ;
     101        stateValue                      ->      LSQUARE integerConstant (COMMA integerConstant)* RSQUARE ;
    107102
    108103        //     
     
    121116        // c o d e   b l o c k  // (32,64,128,256,...)
    122117        //
    123         // codeBlock                    ->              CODEBLOCK codeBlockWidthSpecifier!      { @codeBlockWidth = @:value; }
     118        // codeBlock                    ->              CODEBLOCK codeBlockWidthSpecifier!      { @codeBlockWidth = @:stateValue; }
    124119        //                                                                                                                                      blockStmt (TERMINATOR)? ;
    125120        //                             
     
    130125        //
    131126        stmt                                    #->     localVarDecl | funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt  ;
    132         funcCallOrAssignStmt    #-> expr (assignRest _promote_) ? TERMINATOR ; // add SA to validate expr is a function call   
    133         idisaFuncCallArgList    ->  (expr (COMMA expr)*)? ;
    134         assignOperator                  ->      ASSIGN;                                 
     127        funcCallOrAssignStmt    #-> expr (assignRest _promote_) ? TERMINATOR ; // KH: TODO Add Semantic Analysis pass to validate expr non-terminal is of function call node type       
     128        idisaFuncCallArgList    ->  (expr (COMMA expr)*) ? ;
     129        assignOperator                  ->      ASSIGN ;                               
    135130        assignRest                              ->      assignOperator^! expr ;                         
    136131        ifStmt                                  ->      IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                     
    137132        whileStmt                               ->      WHILE LROUND expr RROUND blockStmt ;
    138         returnStmt                              ->      RETURN (expr)? TERMINATOR ;
     133        returnStmt                              ->      RETURN (expr) ? TERMINATOR ;
    139134        localVarDecl                    ->      type varName (assignOperator^! expr) ? TERMINATOR ;
    140135        varName                                 #-> compoundIdentifier ;
  • proto/pabloj/trunk/input/test/pabloB/proto/parabix2_pablo.pablob

    r3192 r3257  
    131131kernel Classify_bytes_Validate_utf8 
    132132{
    133         init
     133        state
    134134        {
    135135         
     
    490490kernel Parse_refs
    491491{
    492         init
     492        state
    493493        {
    494494               
     
    573573kernel Validate_xml_names
    574574{
    575         init
     575        state
    576576        {
    577577               
     
    634634kernel Do_check_streams
    635635{
    636         init
     636        state
    637637        {
    638638               
  • proto/pabloj/trunk/input/test/pabloB/test.pablob

    r3192 r3257  
    33kernel KernelName
    44{
    5     init
     5    state
    66    {
    7            
     7        look_ahead = [0];
     8        look_behind = [0];
     9        carry_init = [0,0,1,1];
    810    }
    911
  • proto/pabloj/trunk/src/pabloB/ast/ASTTransformer.java

    r3192 r3257  
    5050        public ASTNode visit(IfStmtNode node);
    5151
    52         public ASTNode visit(InitBlockNode node);
    53 
    54         public ASTNode visit(InitDefNode node);
    55 
    5652        public ASTNode visit(IntTypeNode node);
    5753
     
    7066        public ASTNode visit(ReturnStmtNode node);
    7167
    72         public ASTNode visit(StateIdentifierNode node);
    73 
    74         public ASTNode visit(StateInitListNode node);
    75 
    76         public ASTNode visit(StateInitStmtNode node);
    77 
    78         public ASTNode visit(StateSizeNode node);
    79 
    80         public ASTNode visit(StateValueNode node);
     68        public ASTNode visit(StateDefNode node);
     69
     70        public ASTNode visit(StateParameterNode node);
     71
     72        public ASTNode visit(StateParametersNode node);
     73
     74        public ASTNode visit(StateValueListNode node);
    8175
    8276        public ASTNode visit(StringConstantNode node);
     
    181175                }
    182176
    183                 public ASTNode visit(InitBlockNode node) {
    184                         return defaultVisit(node);
    185                 }
    186 
    187                 public ASTNode visit(InitDefNode node) {
    188                         return defaultVisit(node);
    189                 }
    190 
    191177                public ASTNode visit(IntTypeNode node) {
    192178                        return defaultVisit(node);
     
    221207                }
    222208
    223                 public ASTNode visit(StateIdentifierNode node) {
    224                         return defaultVisit(node);
    225                 }
    226 
    227                 public ASTNode visit(StateInitListNode node) {
    228                         return defaultVisit(node);
    229                 }
    230 
    231                 public ASTNode visit(StateInitStmtNode node) {
    232                         return defaultVisit(node);
    233                 }
    234 
    235                 public ASTNode visit(StateSizeNode node) {
    236                         return defaultVisit(node);
    237                 }
    238 
    239                 public ASTNode visit(StateValueNode node) {
     209                public ASTNode visit(StateDefNode node) {
     210                        return defaultVisit(node);
     211                }
     212
     213                public ASTNode visit(StateParameterNode node) {
     214                        return defaultVisit(node);
     215                }
     216
     217                public ASTNode visit(StateParametersNode node) {
     218                        return defaultVisit(node);
     219                }
     220
     221                public ASTNode visit(StateValueListNode node) {
    240222                        return defaultVisit(node);
    241223                }
  • proto/pabloj/trunk/src/pabloB/ast/ASTVisitor.java

    r3192 r3257  
    7171        public T visitLeave(IfStmtNode node, List<T> childResults);
    7272
    73         public void visitEnter(InitBlockNode node);
    74         public T visitLeave(InitBlockNode node, List<T> childResults);
    75 
    76         public void visitEnter(InitDefNode node);
    77         public T visitLeave(InitDefNode node, List<T> childResults);
    78 
    7973        public void visitEnter(IntTypeNode node);
    8074        public T visitLeave(IntTypeNode node, List<T> childResults);
     
    10195        public T visitLeave(ReturnStmtNode node, List<T> childResults);
    10296
    103         public void visitEnter(StateIdentifierNode node);
    104         public T visitLeave(StateIdentifierNode node, List<T> childResults);
    105 
    106         public void visitEnter(StateInitListNode node);
    107         public T visitLeave(StateInitListNode node, List<T> childResults);
    108 
    109         public void visitEnter(StateInitStmtNode node);
    110         public T visitLeave(StateInitStmtNode node, List<T> childResults);
    111 
    112         public void visitEnter(StateSizeNode node);
    113         public T visitLeave(StateSizeNode node, List<T> childResults);
    114 
    115         public void visitEnter(StateValueNode node);
    116         public T visitLeave(StateValueNode node, List<T> childResults);
     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(StateParametersNode node);
     104        public T visitLeave(StateParametersNode node, List<T> childResults);
     105
     106        public void visitEnter(StateValueListNode node);
     107        public T visitLeave(StateValueListNode node, List<T> childResults);
    117108
    118109        public void visitEnter(StringConstantNode node);
     
    294285                }
    295286
    296                 public void visitEnter(InitBlockNode node) {
    297                         defaultVisitEnter(node);
    298                 }
    299                 public T visitLeave(InitBlockNode node, List<T> childResults) {
    300                         return defaultVisitLeave(node, childResults);
    301                 }
    302 
    303                 public void visitEnter(InitDefNode node) {
    304                         defaultVisitEnter(node);
    305                 }
    306                 public T visitLeave(InitDefNode node, List<T> childResults) {
    307                         return defaultVisitLeave(node, childResults);
    308                 }
    309 
    310287                public void visitEnter(IntTypeNode node) {
    311288                        defaultVisitEnter(node);
     
    364341                }
    365342
    366                 public void visitEnter(StateIdentifierNode node) {
    367                         defaultVisitEnter(node);
    368                 }
    369                 public T visitLeave(StateIdentifierNode node, List<T> childResults) {
    370                         return defaultVisitLeave(node, childResults);
    371                 }
    372 
    373                 public void visitEnter(StateInitListNode node) {
    374                         defaultVisitEnter(node);
    375                 }
    376                 public T visitLeave(StateInitListNode node, List<T> childResults) {
    377                         return defaultVisitLeave(node, childResults);
    378                 }
    379 
    380                 public void visitEnter(StateInitStmtNode node) {
    381                         defaultVisitEnter(node);
    382                 }
    383                 public T visitLeave(StateInitStmtNode node, List<T> childResults) {
    384                         return defaultVisitLeave(node, childResults);
    385                 }
    386 
    387                 public void visitEnter(StateSizeNode node) {
    388                         defaultVisitEnter(node);
    389                 }
    390                 public T visitLeave(StateSizeNode node, List<T> childResults) {
    391                         return defaultVisitLeave(node, childResults);
    392                 }
    393 
    394                 public void visitEnter(StateValueNode node) {
    395                         defaultVisitEnter(node);
    396                 }
    397                 public T visitLeave(StateValueNode node, List<T> childResults) {
     343                public void visitEnter(StateDefNode node) {
     344                        defaultVisitEnter(node);
     345                }
     346                public T visitLeave(StateDefNode node, List<T> childResults) {
     347                        return defaultVisitLeave(node, childResults);
     348                }
     349
     350                public void visitEnter(StateParameterNode node) {
     351                        defaultVisitEnter(node);
     352                }
     353                public T visitLeave(StateParameterNode node, List<T> childResults) {
     354                        return defaultVisitLeave(node, childResults);
     355                }
     356
     357                public void visitEnter(StateParametersNode node) {
     358                        defaultVisitEnter(node);
     359                }
     360                public T visitLeave(StateParametersNode node, List<T> childResults) {
     361                        return defaultVisitLeave(node, childResults);
     362                }
     363
     364                public void visitEnter(StateValueListNode node) {
     365                        defaultVisitEnter(node);
     366                }
     367                public T visitLeave(StateValueListNode node, List<T> childResults) {
    398368                        return defaultVisitLeave(node, childResults);
    399369                }
  • proto/pabloj/trunk/src/pabloB/ast/SimpleVisitor.java

    r3192 r3257  
    5151        public void visit(IfStmtNode node);
    5252
    53         public void visit(InitBlockNode node);
    54 
    55         public void visit(InitDefNode node);
    56 
    5753        public void visit(IntTypeNode node);
    5854
     
    7167        public void visit(ReturnStmtNode node);
    7268
    73         public void visit(StateIdentifierNode node);
    74 
    75         public void visit(StateInitListNode node);
    76 
    77         public void visit(StateInitStmtNode node);
    78 
    79         public void visit(StateSizeNode node);
    80 
    81         public void visit(StateValueNode node);
     69        public void visit(StateDefNode node);
     70
     71        public void visit(StateParameterNode node);
     72
     73        public void visit(StateParametersNode node);
     74
     75        public void visit(StateValueListNode node);
    8276
    8377        public void visit(StringConstantNode node);
     
    182176                }
    183177
    184                 public void visit(InitBlockNode node) {
    185                         defaultVisit(node);
    186                 }
    187 
    188                 public void visit(InitDefNode node) {
    189                         defaultVisit(node);
    190                 }
    191 
    192178                public void visit(IntTypeNode node) {
    193179                        defaultVisit(node);
     
    222208                }
    223209
    224                 public void visit(StateIdentifierNode node) {
    225                         defaultVisit(node);
    226                 }
    227 
    228                 public void visit(StateInitListNode node) {
    229                         defaultVisit(node);
    230                 }
    231 
    232                 public void visit(StateInitStmtNode node) {
    233                         defaultVisit(node);
    234                 }
    235 
    236                 public void visit(StateSizeNode node) {
    237                         defaultVisit(node);
    238                 }
    239 
    240                 public void visit(StateValueNode node) {
     210                public void visit(StateDefNode node) {
     211                        defaultVisit(node);
     212                }
     213
     214                public void visit(StateParameterNode node) {
     215                        defaultVisit(node);
     216                }
     217
     218                public void visit(StateParametersNode node) {
     219                        defaultVisit(node);
     220                }
     221
     222                public void visit(StateValueListNode node) {
    241223                        defaultVisit(node);
    242224                }
  • proto/pabloj/trunk/src/pabloB/ast/VoidVisitor.java

    r3192 r3257  
    6969        public void visitLeave(IfStmtNode node);
    7070
    71         public void visitEnter(InitBlockNode node);
    72         public void visitLeave(InitBlockNode node);
    73 
    74         public void visitEnter(InitDefNode node);
    75         public void visitLeave(InitDefNode node);
    76 
    7771        public void visitEnter(IntTypeNode node);
    7872        public void visitLeave(IntTypeNode node);
     
    9993        public void visitLeave(ReturnStmtNode node);
    10094
    101         public void visitEnter(StateIdentifierNode node);
    102         public void visitLeave(StateIdentifierNode node);
    103 
    104         public void visitEnter(StateInitListNode node);
    105         public void visitLeave(StateInitListNode node);
    106 
    107         public void visitEnter(StateInitStmtNode node);
    108         public void visitLeave(StateInitStmtNode node);
    109 
    110         public void visitEnter(StateSizeNode node);
    111         public void visitLeave(StateSizeNode node);
    112 
    113         public void visitEnter(StateValueNode node);
    114         public void visitLeave(StateValueNode node);
     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(StateParametersNode node);
     102        public void visitLeave(StateParametersNode node);
     103
     104        public void visitEnter(StateValueListNode node);
     105        public void visitLeave(StateValueListNode node);
    115106
    116107        public void visitEnter(StringConstantNode node);
     
    291282                }
    292283
    293                 public void visitEnter(InitBlockNode node) {
    294                         defaultVisitEnter(node);
    295                 }
    296                 public void visitLeave(InitBlockNode node) {
    297                         defaultVisitLeave(node);
    298                 }
    299 
    300                 public void visitEnter(InitDefNode node) {
    301                         defaultVisitEnter(node);
    302                 }
    303                 public void visitLeave(InitDefNode node) {
    304                         defaultVisitLeave(node);
    305                 }
    306 
    307284                public void visitEnter(IntTypeNode node) {
    308285                        defaultVisitEnter(node);
     
    361338                }
    362339
    363                 public void visitEnter(StateIdentifierNode node) {
    364                         defaultVisitEnter(node);
    365                 }
    366                 public void visitLeave(StateIdentifierNode node) {
    367                         defaultVisitLeave(node);
    368                 }
    369 
    370                 public void visitEnter(StateInitListNode node) {
    371                         defaultVisitEnter(node);
    372                 }
    373                 public void visitLeave(StateInitListNode node) {
    374                         defaultVisitLeave(node);
    375                 }
    376 
    377                 public void visitEnter(StateInitStmtNode node) {
    378                         defaultVisitEnter(node);
    379                 }
    380                 public void visitLeave(StateInitStmtNode node) {
    381                         defaultVisitLeave(node);
    382                 }
    383 
    384                 public void visitEnter(StateSizeNode node) {
    385                         defaultVisitEnter(node);
    386                 }
    387                 public void visitLeave(StateSizeNode node) {
    388                         defaultVisitLeave(node);
    389                 }
    390 
    391                 public void visitEnter(StateValueNode node) {
    392                         defaultVisitEnter(node);
    393                 }
    394                 public void visitLeave(StateValueNode node) {
     340                public void visitEnter(StateDefNode node) {
     341                        defaultVisitEnter(node);
     342                }
     343                public void visitLeave(StateDefNode node) {
     344                        defaultVisitLeave(node);
     345                }
     346
     347                public void visitEnter(StateParameterNode node) {
     348                        defaultVisitEnter(node);
     349                }
     350                public void visitLeave(StateParameterNode node) {
     351                        defaultVisitLeave(node);
     352                }
     353
     354                public void visitEnter(StateParametersNode node) {
     355                        defaultVisitEnter(node);
     356                }
     357                public void visitLeave(StateParametersNode node) {
     358                        defaultVisitLeave(node);
     359                }
     360
     361                public void visitEnter(StateValueListNode node) {
     362                        defaultVisitEnter(node);
     363                }
     364                public void visitLeave(StateValueListNode node) {
    395365                        defaultVisitLeave(node);
    396366                }
  • proto/pabloj/trunk/src/pabloB/lexicalAnalyzer/Lextant.java

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

    r3197 r3257  
    222222                expect(Lextant.LCURLY);
    223223                {
    224                         ASTNode child = parseInitDef();
     224                        ASTNode child = parseStateDef();
    225225                        result.appendChild(child);
    226226                        allChildren.add(child);
     
    274274        }
    275275         
    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);
     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);
    283283                result.setProductionTag(9);
    284284                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    285                 expect(Lextant.INIT);
    286                 {
    287                         ASTNode child = parseInitBlock();
    288                         result.appendChild(child);
    289                         allChildren.add(child);
    290                 }
    291                 if( nowReading.isLextant(Lextant.TERMINATOR) ) {
    292                         expect(Lextant.TERMINATOR);
    293                 }
    294                 if(allowCompression) {
    295                         return result;
    296                 }
    297                 return result;
    298         }
    299          
    300         public ASTNode parseInitBlock() {
    301                 if( !(nowReading.isLextant(Lextant.LCURLY)) ) {
    302                         return syntaxErrorNode("initBlock² [LCURLY¹]");
    303                 }
    304        
    305                 boolean allowCompression = true;
    306                 ASTNode result = new InitBlockNode(nowReading);
    307                 result.setProductionTag(10);
    308                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     285                expect(Lextant.STATE);
    309286                expect(Lextant.LCURLY);
    310                 while( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    311                         {
    312                                 ASTNode child = parseStateInitStmt();
    313                                 result.appendChild(child);
    314                                 allChildren.add(child);
    315                         }
    316                 }
    317                 expect(Lextant.RCURLY);
    318                 if(allowCompression) {
    319                         return compressIfPossible(result);
    320                 }
    321                 return result;
    322         }
    323          
    324         public ASTNode parseStateInitStmt() {
    325                 if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    326                         return syntaxErrorNode("stateInitStmt² [IDENTIFIER¹]");
    327                 }
    328        
    329                 boolean allowCompression = true;
    330                 ASTNode result = new StateInitStmtNode(nowReading);
    331                 result.setProductionTag(11);
    332                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    333                 {
    334                         ASTNode child = parseStateIdentifier();
    335                         result.appendChild(child);
    336                         allChildren.add(child);
    337                 }
    338                 expect(Lextant.LSQUARE);
    339                 {
    340                         ASTNode child = parseStateSize();
    341                         result.appendChild(child);
    342                         allChildren.add(child);
    343                 }
    344                 expect(Lextant.RSQUARE);
    345                 expect(Lextant.ASSIGN);
    346                 expect(Lextant.LCURLY);
    347                 {
    348                         ASTNode child = parseStateInitList();
     287                {
     288                        ASTNode child = parseStateParameters();
    349289                        result.appendChild(child);
    350290                        allChildren.add(child);
     
    360300        }
    361301         
    362         public ASTNode parseStateIdentifier() {
     302        public ASTNode parseStateParameters() {
     303                boolean allowCompression = true;
     304                ASTNode result = new StateParametersNode(nowReading);
     305                result.setProductionTag(10);
     306                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     307                while( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     308                        {
     309                                ASTNode child = parseStateParameter();
     310                                result.appendChild(child);
     311                                allChildren.add(child);
     312                        }
     313                }
     314                if(allowCompression) {
     315                        return compressIfPossible(result);
     316                }
     317                return result;
     318        }
     319         
     320        public ASTNode parseStateParameter() {
    363321                if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    364                         return syntaxErrorNode("stateIdentifier² [IDENTIFIER¹]");
    365                 }
    366        
    367                 boolean allowCompression = true;
    368                 ASTNode result = new StateIdentifierNode(nowReading);
     322                        return syntaxErrorNode("stateParameter² [IDENTIFIER¹]");
     323                }
     324       
     325                boolean allowCompression = true;
     326                ASTNode result = new StateParameterNode(nowReading);
     327                result.setProductionTag(11);
     328                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     329                {
     330                        ASTNode child = parseStateName();
     331                        result.appendChild(child);
     332                        allChildren.add(child);
     333                }
     334                expect(Lextant.ASSIGN);
     335                {
     336                        ASTNode child = parseStateValueList();
     337                        result.appendChild(child);
     338                        allChildren.add(child);
     339                }
     340                expect(Lextant.TERMINATOR);
     341                if(allowCompression) {
     342                        return result;
     343                }
     344                return result;
     345        }
     346         
     347        public ASTNode parseStateName() {
     348                if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     349                        return syntaxErrorNode("stateName² [IDENTIFIER¹]");
     350                }
     351       
     352                boolean allowCompression = true;
     353                ASTNode result = new ASTNode(nowReading);
    369354                result.setProductionTag(12);
    370355                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    371                 if( !(nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    372                         return syntaxErrorNode("IDENTIFIER");
    373                 }
    374                 readToken();
    375                 if(allowCompression) {
    376                         return result;
    377                 }
    378                 return result;
    379         }
    380          
    381         public ASTNode parseStateSize() {
    382                 if( !((nowReading.isLexicalType(LexicalType.INTEGER_CONST))) ) {
    383                         return syntaxErrorNode("stateSize² [INTEGER_CONST¹]");
    384                 }
    385        
    386                 boolean allowCompression = true;
    387                 ASTNode result = new StateSizeNode(nowReading);
     356                {
     357                        ASTNode child = parseIdentifier();
     358                        result.appendChild(child);
     359                        allChildren.add(child);
     360                }
     361                if(allowCompression) {
     362                        return compressIfPossible(result);
     363                }
     364                return result;
     365        }
     366         
     367        public ASTNode parseStateValueList() {
     368                if( !(nowReading.isLextant(Lextant.LSQUARE)) ) {
     369                        return syntaxErrorNode("stateValueList² [LSQUARE¹]");
     370                }
     371       
     372                boolean allowCompression = true;
     373                ASTNode result = new StateValueListNode(nowReading);
    388374                result.setProductionTag(13);
    389375                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    390                 {
    391                         ASTNode child = parseIntegerConstant();
    392                         result.appendChild(child);
    393                         allChildren.add(child);
    394                 }
    395                 if(allowCompression) {
    396                         return result;
    397                 }
    398                 return result;
    399         }
    400          
    401         public ASTNode parseStateInitList() {
    402                 if( !((nowReading.isLexicalType(LexicalType.INTEGER_CONST))) ) {
    403                         return syntaxErrorNode("stateInitList² [INTEGER_CONST¹]");
    404                 }
    405        
    406                 boolean allowCompression = true;
    407                 ASTNode result = new StateInitListNode(nowReading);
    408                 result.setProductionTag(14);
    409                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     376                expect(Lextant.LSQUARE);
    410377                {
    411378                        ASTNode child = parseIntegerConstant();
     
    421388                        }
    422389                }
    423                 if(allowCompression) {
    424                         return result;
    425                 }
    426                 return result;
    427         }
    428          
    429         public ASTNode parseStateValue() {
    430                 if( !((nowReading.isLexicalType(LexicalType.INTEGER_CONST))) ) {
    431                         return syntaxErrorNode("stateValue² [INTEGER_CONST¹]");
    432                 }
    433        
    434                 boolean allowCompression = true;
    435                 ASTNode result = new StateValueNode(nowReading);
    436                 result.setProductionTag(15);
    437                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    438                 {
    439                         ASTNode child = parseIntegerConstant();
    440                         result.appendChild(child);
    441                         allChildren.add(child);
    442                 }
     390                expect(Lextant.RSQUARE);
    443391                if(allowCompression) {
    444392                        return result;
     
    454402                boolean allowCompression = true;
    455403                ASTNode result = new FuncDefNode(nowReading);
    456                 result.setProductionTag(16);
     404                result.setProductionTag(14);
    457405                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    458406                expect(Lextant.FUNCTION);
     
    497445                boolean allowCompression = true;
    498446                ASTNode result = new ASTNode(nowReading);
    499                 result.setProductionTag(17);
     447                result.setProductionTag(15);
    500448                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    501449                {
     
    517465                boolean allowCompression = true;
    518466                ASTNode result = new ParameterListNode(nowReading);
    519                 result.setProductionTag(18);
     467                result.setProductionTag(16);
    520468                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    521469                {
     
    545493                boolean allowCompression = true;
    546494                ASTNode result = new ASTNode(nowReading);
    547                 result.setProductionTag(19);
     495                result.setProductionTag(17);
    548496                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    549497                {
     
    565513                boolean allowCompression = true;
    566514                ASTNode result = new ParameterNode(nowReading);
    567                 result.setProductionTag(20);
     515                result.setProductionTag(18);
    568516                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    569517                {
     
    590538                boolean allowCompression = true;
    591539                ASTNode result = new ASTNode(nowReading);
    592                 result.setProductionTag(21);
     540                result.setProductionTag(19);
    593541                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    594542                {
     
    610558                boolean allowCompression = true;
    611559                ASTNode result = new ASTNode(nowReading);
    612                 result.setProductionTag(22);
     560                result.setProductionTag(20);
    613561                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    614562                {
     
    630578                boolean allowCompression = true;
    631579                ASTNode result = new ASTNode(nowReading);
    632                 result.setProductionTag(23);
     580                result.setProductionTag(21);
    633581                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    634582                {
     
    650598                boolean allowCompression = true;
    651599                ASTNode result = new ASTNode(nowReading);
    652                 result.setProductionTag(24);
     600                result.setProductionTag(22);
    653601                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    654602                if( nowReading.isLextant(Lextant.BITBLOCK, Lextant.BITFIELD, Lextant.BOOL, Lextant.INT, Lextant.STRUCT, Lextant.VOID) ) {
     
    703651                boolean allowCompression = true;
    704652                ASTNode result = new FuncCallOrAssignStmtNode(nowReading);
    705                 result.setProductionTag(25);
     653                result.setProductionTag(23);
    706654                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    707655                {
     
    729677                boolean allowCompression = true;
    730678                ASTNode result = new IdisaFuncCallArgListNode(nowReading);
    731                 result.setProductionTag(26);
     679                result.setProductionTag(24);
    732680                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    733681                if( nowReading.isLextant(Lextant.LROUND) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    759707                boolean allowCompression = true;
    760708                ASTNode result = new AssignOperatorNode(nowReading);
    761                 result.setProductionTag(27);
     709                result.setProductionTag(25);
    762710                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    763711                expect(Lextant.ASSIGN);
     
    775723                boolean allowCompression = true;
    776724                ASTNode result = new AssignNode(nowReading);
    777                 result.setProductionTag(28);
     725                result.setProductionTag(26);
    778726                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    779727                {
     
    801749                boolean allowCompression = true;
    802750                ASTNode result = new IfStmtNode(nowReading);
    803                 result.setProductionTag(29);
     751                result.setProductionTag(27);
    804752                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    805753                expect(Lextant.IF);
     
    837785                boolean allowCompression = true;
    838786                ASTNode result = new WhileStmtNode(nowReading);
    839                 result.setProductionTag(30);
     787                result.setProductionTag(28);
    840788                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    841789                expect(Lextant.WHILE);
     
    865813                boolean allowCompression = true;
    866814                ASTNode result = new ReturnStmtNode(nowReading);
    867                 result.setProductionTag(31);
     815                result.setProductionTag(29);
    868816                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    869817                expect(Lextant.RETURN);
     
    889837                boolean allowCompression = true;
    890838                ASTNode result = new LocalVarDeclNode(nowReading);
    891                 result.setProductionTag(32);
     839                result.setProductionTag(30);
    892840                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    893841                {
     
    928876                boolean allowCompression = true;
    929877                ASTNode result = new ASTNode(nowReading);
    930                 result.setProductionTag(33);
     878                result.setProductionTag(31);
    931879                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    932880                {
     
    948896                boolean allowCompression = true;
    949897                ASTNode result = new BlockStmtNode(nowReading);
    950                 result.setProductionTag(34);
     898                result.setProductionTag(32);
    951899                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    952900                expect(Lextant.LCURLY);
     
    972920                boolean allowCompression = true;
    973921                ASTNode result = new ASTNode(nowReading);
    974                 result.setProductionTag(35);
     922                result.setProductionTag(33);
    975923                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    976924                if( nowReading.isLextant(Lextant.LROUND) ) {
     
    1036984                boolean allowCompression = true;
    1037985                ASTNode result = new ASTNode(nowReading);
    1038                 result.setProductionTag(36);
     986                result.setProductionTag(34);
    1039987                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1040988                if( (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    10681016                boolean allowCompression = true;
    10691017                ASTNode result = new IntegerConstantNode(nowReading);
    1070                 result.setProductionTag(37);
     1018                result.setProductionTag(35);
    10711019                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10721020                if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     
    10941042                boolean allowCompression = true;
    10951043                ASTNode result = new StringConstantNode(nowReading);
    1096                 result.setProductionTag(38);
     1044                result.setProductionTag(36);
    10971045                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10981046                if( (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    11241072                boolean allowCompression = true;
    11251073                ASTNode result = new CompoundIdentifierNode(nowReading);
    1126                 result.setProductionTag(39);
     1074                result.setProductionTag(37);
    11271075                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11281076                {
     
    11531101                boolean allowCompression = true;
    11541102                ASTNode result = new IdentifierNode(nowReading);
    1155                 result.setProductionTag(40);
     1103                result.setProductionTag(38);
    11561104                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11571105                if( !(nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     
    11721120                boolean allowCompression = true;
    11731121                ASTNode result = new FuncCallNode(nowReading);
    1174                 result.setProductionTag(41);
     1122                result.setProductionTag(39);
    11751123                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11761124                result.setToken(nowReading);
     
    11911139                boolean allowCompression = true;
    11921140                ASTNode result = new FuncCallArgListNode(nowReading);
    1193                 result.setProductionTag(42);
     1141                result.setProductionTag(40);
    11941142                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11951143                if( nowReading.isLextant(Lextant.LROUND) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    12211169                boolean allowCompression = true;
    12221170                ASTNode result = new IdisaFuncCallNode(nowReading);
    1223                 result.setProductionTag(43);
     1171                result.setProductionTag(41);
    12241172                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12251173                result.setToken(nowReading);
     
    12511199                boolean allowCompression = true;
    12521200                ASTNode result = new FieldWidthNode(nowReading);
    1253                 result.setProductionTag(44);
     1201                result.setProductionTag(42);
    12541202                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12551203                {
     
    12711219                boolean allowCompression = true;
    12721220                ASTNode result = new ASTNode(nowReading);
    1273                 result.setProductionTag(45);
     1221                result.setProductionTag(43);
    12741222                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12751223                if( nowReading.isLextant(Lextant.BITBLOCK, Lextant.BOOL, Lextant.INT, Lextant.VOID) ) {
     
    13101258                boolean allowCompression = true;
    13111259                ASTNode result = new ASTNode(nowReading);
    1312                 result.setProductionTag(46);
     1260                result.setProductionTag(44);
    13131261                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13141262                if( nowReading.isLextant(Lextant.INT) ) {
     
    13561304                boolean allowCompression = true;
    13571305                ASTNode result = new IntTypeNode(nowReading);
    1358                 result.setProductionTag(47);
     1306                result.setProductionTag(45);
    13591307                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13601308                expect(Lextant.INT);
     
    13721320                boolean allowCompression = true;
    13731321                ASTNode result = new VoidTypeNode(nowReading);
    1374                 result.setProductionTag(48);
     1322                result.setProductionTag(46);
    13751323                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13761324                expect(Lextant.VOID);
     
    13881336                boolean allowCompression = true;
    13891337                ASTNode result = new BoolTypeNode(nowReading);
    1390                 result.setProductionTag(49);
     1338                result.setProductionTag(47);
    13911339                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13921340                expect(Lextant.BOOL);
     
    14041352                boolean allowCompression = true;
    14051353                ASTNode result = new BitBlockTypeNode(nowReading);
    1406                 result.setProductionTag(50);
     1354                result.setProductionTag(48);
    14071355                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    14081356                expect(Lextant.BITBLOCK);
     
    14201368                boolean allowCompression = true;
    14211369                ASTNode result = new BitFieldTypeNode(nowReading);
    1422                 result.setProductionTag(51);
     1370                result.setProductionTag(49);
    14231371                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    14241372                expect(Lextant.BITFIELD);
     
    14451393                boolean allowCompression = true;
    14461394                ASTNode result = new IntegerConstantNode(nowReading);
    1447                 result.setProductionTag(52);
     1395                result.setProductionTag(50);
    14481396                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    14491397                if( nowReading.isLextant(Lextant.LANGLE) ) {
     
    14811429                boolean allowCompression = true;
    14821430                ASTNode result = new StructTypeNode(nowReading);
    1483                 result.setProductionTag(53);
     1431                result.setProductionTag(51);
    14841432                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    14851433                expect(Lextant.STRUCT);
     
    15021450                boolean allowCompression = true;
    15031451                ASTNode result = new ASTNode(nowReading);
    1504                 result.setProductionTag(54);
     1452                result.setProductionTag(52);
    15051453                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    15061454                {
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Generators.java

    r3238 r3257  
    102102       
    103103        public static KernelDefNode makeKernelDef(String identifier,
    104                         InitDefNode initDefNode,
     104                        StateDefNode stateDefNode,
    105105                        FuncDefNode funcDefNode,
    106106                        FuncDefNode optFuncDefNode,
     
    112112                       
    113113                        kernelDefNode.appendChild(identifierNode);
    114                         kernelDefNode.appendChild(initDefNode);
     114                        kernelDefNode.appendChild(stateDefNode);
    115115                        kernelDefNode.appendChild(funcDefNode.deepCopy());
    116116                        kernelDefNode.appendChild(optFuncDefNode.deepCopy());
     
    118118                        return kernelDefNode;
    119119        }       
    120        
    121         /*
    122         private static void addFuncDefNode(KernelDefNode kernelDefNode, FuncDefNode funcDefNode) {
    123                 assert (kernelDefNode.nChildren() == 2);
    124                 kernelDefNode.appendChild(funcDefNode);
    125         }
    126         */
    127        
     120
    128121        public static void addFuncCallNode(KernelDefNode kernelDefNode, FuncCallNode funcCallNode) {
    129122                kernelDefNode.appendChild(funcCallNode);
    130123        }       
    131        
    132         public static InitDefNode makeInitDefNode (Locator locator) {
    133                
    134                 LextantToken initDefToken = Generators.makeLextantToken(Lextant.KERNEL, locator);
    135                 InitDefNode initDefNode = new InitDefNode(initDefToken);
    136                
    137                 LextantToken initBlockToken = Generators.makeLextantToken(Lextant.LCURLY, locator);
    138                 InitBlockNode initBlockNode = new InitBlockNode(initBlockToken);
    139                
    140                 initDefNode.appendChild(initBlockNode);
    141                
    142                 return initDefNode;
     124
     125    // stateDef            #->  STATE LCURLY stateParameter* RCURLY TERMINATOR? ;
     126    public static StateDefNode makeStateDefNode (Locator locator) {
     127        StateDefNode stateDef = new StateDefNode(Generators.makeLextantToken(Lextant.LCURLY, locator));
     128        return stateDef;
     129    }
     130       
     131        public static StateDefNode makeStateDefNode (List<StateParameterNode> stateParameters, Locator locator) {
     132                StateDefNode stateDef = new StateDefNode(Generators.makeLextantToken(Lextant.LCURLY, locator));
     133                for(StateParameterNode stateParameter : stateParameters) {
     134                    stateDef.appendChild(stateParameter);
     135                }
     136                return stateDef;
     137        }
     138       
     139        // stateParameter      ->  stateName ASSIGN stateValue TERMINATOR ;
     140        public static StateParameterNode makeStateParameterNode (IdentifierNode identifier, StateValueNode stateValue) {
     141            StateParameterNode stateParameter = new StateParameterNode(identifier.getToken());
     142            stateParameter.appendChild(identifier);
     143            stateParameter.appendChild(stateValue);
     144            return stateParameter;
     145        }
     146   
     147        // stateValue          ->  LSQUARE integerConstant (COMMA integerConstant)* RSQUARE ;
     148        public static StateValueNode makeStateValueNode(List<Integer> values, Locator locator) {
     149            StateValueNode stateValue = new StateValueNode(Generators.makeLextantToken(Lextant.LSQUARE, locator));
     150        for(Integer i : values) {
     151            IntegerConstantNode n = Generators.makeIntegerConstantNode(i, locator);
     152            stateValue.appendChild(n);
     153        }           
     154            return stateValue;
    143155        }
    144156       
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Generators.java

    r3240 r3257  
    5252                return localVarDeclNode;
    5353        }
    54 
    55        
    56        
    5754       
    5855        // Make function Call variants 
     
    6360               
    6461        public static FuncCallNode makeFuncCallNode(String identifier, Locator locator, ASTNode ...args) {
    65                
    6662                FuncCallNode node = Generators.makeFuncCallNode(identifier, locator);
    6763                Generators.addFuncCallArgs(node, args);
     
    7066
    7167        public static FuncCallNode makeFuncCallNode(String identifier, Locator locator, List<ASTNode> args) {
    72                
    7368                FuncCallNode node = Generators.makeFuncCallNode(identifier, locator);
    7469                Generators.addFuncCallArgs(node, args);
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/PabloS2PabloBXFormer.java

    r3253 r3257  
    11/*
    2  * Transform PabloS AST to PabloB AST.
     2 * Transforms PabloS AST to PabloB AST.
    33 *
    44 * @author Ken Herdy <ksherdy at sfu dot ca>
     
    1313
    1414import pabloB.ast.FuncCallNode;
     15import pabloB.ast.StateParameterNode;
    1516import pabloS.ast.ASTVisitor.Default;
    1617import pabloS.lexicalAnalyzer.Lextant;
     
    3536        private Map<String, CarryInfoSet> carryInfoSetMap;
    3637        private CarrySetEncoder carrySetEncoder;
    37        
    38         /*
    39         public PabloS2PabloBXFormer(compiler.symbols.SymbolTable symbolTable) {
    40         this.decoratedASTTree = null;
    41         this.optDecoratedASTTree = null;
    42         this.symbolTable = symbolTable;
    43          */
    4438 
    4539    public PabloS2PabloBXFormer(Map<String, CarryInfoSet> carryInfoSetMap, CarrySetEncoder carrySetEncoder) {
     
    4943        this.carrySetEncoder = carrySetEncoder;
    5044    }
    51 
    52     /*   
    53         public pabloB.ast.ASTNode XForm(pabloS.ast.ProgramNode decoratedASTTree) {
    54                 return XForm(decoratedASTTree, decoratedASTTree);
    55     }
    56     */
    5745     
    5846    public pabloB.ast.ASTNode XForm(pabloS.ast.ProgramNode decoratedASTTree, pabloS.ast.ProgramNode optDecoratedASTTree) {
     
    8270                        CarryInfoSet carryInfoSetSymbol = (CarryInfoSet) carryInfoSetMap.get(kernelName);
    8371                       
    84                         pabloB.ast.InitDefNode initDefNode = Generators.makeInitDefNode(funcDefNode);                   
     72                        pabloB.ast.StateDefNode stateDefNode = Generators.makeStateDefNode(funcDefNode);                       
    8573                       
    8674                        // Temporary fix
    87                        
    88                         // Add carry_flip call
    89                        
    90                         // delete children
    91                         /*
    92                         if(carryInfoSetSymbol.getCarry1Count() > 0) {
     75/*                                             
     76            if(carryInfoSetSymbol.getCarry1Count() > 0) {
    9377                                StateInitStmtNode carry1StateNode = Generators.makeStateInitStmtNode(CarryInfoSet.CARRY1STATENAME,
    9478                                                                                                                carryInfoSetSymbol.getCarry1Array(),
    9579                                                                                                                locationToken);                 
    96                                 compiler.ast.pabloB.Accessors.initBlockNode(initDefNode).appendChild(carry1StateNode);
    97                         }
    98                        
     80                               
     81                                IdentifierNode stateName    = makeIdentifierNode();
     82                                StateValueNode stateValue   = makeStateValueNode();
     83                               
     84                                // StateParameterNode stateParameter =
     85                        }
     86           
     87*/                     
     88                        /*
    9989                        if(carryInfoSetSymbol.getCarryNCount() > 0) {
    10090                                StateInitStmtNode carryNStateNode = Generators.makeStateInitStmtNode(CarryInfoSet.CARRYNSTATENAME,
    10191                                                                                                                carryInfoSetSymbol.getCarryNArray(),
    10292                                                                                                                locationToken);
    103                                 compiler.ast.pabloB.Accessors.initBlockNode(initDefNode).appendChild(carryNStateNode);
     93
    10494                        }
    10595                        */
    10696                       
    107                         if(carryInfoSetSymbol.getCarry1Count() > 0) { // TODO update
     97                        if(carryInfoSetSymbol.getCarry1Count() > 0) { // KH: TODO Direct to StateDefNode.
    10898                                               
    10999                                Integer [] carry1Array = carryInfoSetSymbol.getCarry1Array();   
     
    133123                                                                                                carryFlipFuncCall, indexNode);
    134124                                                                                                       
    135                                                         toolchain.pabloB.ast.Accessors.initBlockNode(initDefNode).appendChild(setCarryFuncCall);
     125                                                        // ? toolchain.pabloB.ast.Accessors.initBlockNode(initDefNode).appendChild(setCarryFuncCall);
    136126                                        }
    137127                                }
     
    141131                        pabloB.ast.KernelDefNode kernelDefNode =
    142132                                        Generators.makeKernelDef(kernelName,
    143                                                         initDefNode,
     133                                                        stateDefNode,
    144134                                                        funcDefNode,
    145135                                                        optFuncDefNode,
    146                                                         funcDefNode);
    147                        
    148                         // add carry declare
     136                                                        funcDefNode.getToken());
     137                       
     138                        // add carry declare - hack
    149139                        Generators.addFuncCallNode(kernelDefNode, (pabloB.ast.FuncCallNode) funcDefNode.lastChild());
    150140                       
     
    203193                }
    204194               
    205                 // Special cases.
    206                
     195                ////////////////////////////////////////////////////////////////////////////////////
     196                // Special PabloS to PabloB translation cases.
     197                ////////////////////////////////////////////////////////////////////////////////////
    207198               
    208199                ////////////////////////////////////////////////////////////////////////////////////
    209200                // Translates PabloS stream type to PabloB bitblock type 
    210201                //
    211                 // TODO handle field width attributes on PabloS stream types
     202                // KH: TODO handle field width attributes on PabloS stream types
    212203                //
    213204                ////////////////////////////////////////////////////////////////////////////////////
Note: See TracChangeset for help on using the changeset viewer.