Changeset 3258


Ignore:
Timestamp:
Jun 3, 2013, 6:05:21 PM (6 years ago)
Author:
ksherdy
Message:

Temp fix.

Location:
proto/pabloj/trunk
Files:
8 deleted
8 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/output/cpplang/pablo_definitions.hpp

    r3240 r3258  
    189189{
    190190        Classify_bytes_Validate_utf8()
    191         {
    192                
    193         }
    194          
     191        {}
    195192        IDISA_INLINE void do_block(struct Basis_bits & basis_bits,struct Lex & lex,struct U8 & u8)
    196193        {
     
    548545{
    549546        Parse_CtCDPI()
    550         {
    551                 carry_set_0.SetCarry(carry_set_0.CarryFlip(carry_set_0.GetCarry(2)),2);
    552         }
    553          
     547        {}
    554548        IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams)
    555549        {
     
    891885{
    892886        Parse_tags()
    893         {
    894                
    895         }
    896          
     887        {}
    897888        IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct Tag_Callouts & tag_Callouts)
    898889        {
     
    11641155{
    11651156        Parse_refs()
    1166         {
    1167                
    1168         }
    1169          
     1157        {}
    11701158        IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct Ref_Callouts & ref_Callouts)
    11711159        {
     
    12471235{
    12481236        Validate_xml_names()
    1249         {
    1250                
    1251         }
    1252          
     1237        {}
    12531238        IDISA_INLINE void do_block(struct CtCDPI_Callouts & ctCDPI_Callouts,struct Ref_Callouts & ref_Callouts,struct Tag_Callouts & tag_Callouts,struct Lex & lex,struct U8 & u8,struct Check_streams & check_streams)
    12541239        {
     
    13081293{
    13091294        Do_check_streams()
    1310         {
    1311                
    1312         }
    1313          
     1295        {}
    13141296        IDISA_INLINE void do_block(struct Marker & marker,struct Tag_Callouts & tag_Callouts,struct Check_streams & check_streams)
    13151297        {
  • proto/pabloj/trunk/src/pabloB/ast/ASTTransformer.java

    r3257 r3258  
    7070        public ASTNode visit(StateParameterNode node);
    7171
    72         public ASTNode visit(StateParametersNode node);
    73 
    74         public ASTNode visit(StateValueListNode node);
     72        public ASTNode visit(StateValueNode node);
    7573
    7674        public ASTNode visit(StringConstantNode node);
     
    215213                }
    216214
    217                 public ASTNode visit(StateParametersNode node) {
    218                         return defaultVisit(node);
    219                 }
    220 
    221                 public ASTNode visit(StateValueListNode node) {
     215                public ASTNode visit(StateValueNode node) {
    222216                        return defaultVisit(node);
    223217                }
  • proto/pabloj/trunk/src/pabloB/ast/ASTVisitor.java

    r3257 r3258  
    101101        public T visitLeave(StateParameterNode node, List<T> childResults);
    102102
    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);
     103        public void visitEnter(StateValueNode node);
     104        public T visitLeave(StateValueNode node, List<T> childResults);
    108105
    109106        public void visitEnter(StringConstantNode node);
     
    355352                }
    356353
    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) {
     354                public void visitEnter(StateValueNode node) {
     355                        defaultVisitEnter(node);
     356                }
     357                public T visitLeave(StateValueNode node, List<T> childResults) {
    368358                        return defaultVisitLeave(node, childResults);
    369359                }
  • proto/pabloj/trunk/src/pabloB/ast/SimpleVisitor.java

    r3257 r3258  
    7171        public void visit(StateParameterNode node);
    7272
    73         public void visit(StateParametersNode node);
    74 
    75         public void visit(StateValueListNode node);
     73        public void visit(StateValueNode node);
    7674
    7775        public void visit(StringConstantNode node);
     
    216214                }
    217215
    218                 public void visit(StateParametersNode node) {
    219                         defaultVisit(node);
    220                 }
    221 
    222                 public void visit(StateValueListNode node) {
     216                public void visit(StateValueNode node) {
    223217                        defaultVisit(node);
    224218                }
  • proto/pabloj/trunk/src/pabloB/ast/VoidVisitor.java

    r3257 r3258  
    9999        public void visitLeave(StateParameterNode node);
    100100
    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);
     101        public void visitEnter(StateValueNode node);
     102        public void visitLeave(StateValueNode node);
    106103
    107104        public void visitEnter(StringConstantNode node);
     
    352349                }
    353350
    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) {
     351                public void visitEnter(StateValueNode node) {
     352                        defaultVisitEnter(node);
     353                }
     354                public void visitLeave(StateValueNode node) {
    365355                        defaultVisitLeave(node);
    366356                }
  • proto/pabloj/trunk/src/pabloB/parser/Parser.java

    r3257 r3258  
    285285                expect(Lextant.STATE);
    286286                expect(Lextant.LCURLY);
    287                 {
    288                         ASTNode child = parseStateParameters();
    289                         result.appendChild(child);
    290                         allChildren.add(child);
     287                while( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     288                        {
     289                                ASTNode child = parseStateParameter();
     290                                result.appendChild(child);
     291                                allChildren.add(child);
     292                        }
    291293                }
    292294                expect(Lextant.RCURLY);
     
    295297                }
    296298                if(allowCompression) {
    297                         return result;
    298                 }
    299                 return result;
    300         }
    301          
    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) {
    315299                        return compressIfPossible(result);
    316300                }
     
    325309                boolean allowCompression = true;
    326310                ASTNode result = new StateParameterNode(nowReading);
    327                 result.setProductionTag(11);
     311                result.setProductionTag(10);
    328312                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    329313                {
     
    334318                expect(Lextant.ASSIGN);
    335319                {
    336                         ASTNode child = parseStateValueList();
     320                        ASTNode child = parseStateValue();
    337321                        result.appendChild(child);
    338322                        allChildren.add(child);
     
    352336                boolean allowCompression = true;
    353337                ASTNode result = new ASTNode(nowReading);
     338                result.setProductionTag(11);
     339                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     340                {
     341                        ASTNode child = parseIdentifier();
     342                        result.appendChild(child);
     343                        allChildren.add(child);
     344                }
     345                if(allowCompression) {
     346                        return compressIfPossible(result);
     347                }
     348                return result;
     349        }
     350         
     351        public ASTNode parseStateValue() {
     352                if( !(nowReading.isLextant(Lextant.LSQUARE)) ) {
     353                        return syntaxErrorNode("stateValue² [LSQUARE¹]");
     354                }
     355       
     356                boolean allowCompression = true;
     357                ASTNode result = new StateValueNode(nowReading);
    354358                result.setProductionTag(12);
    355                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    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);
    374                 result.setProductionTag(13);
    375359                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    376360                expect(Lextant.LSQUARE);
     
    402386                boolean allowCompression = true;
    403387                ASTNode result = new FuncDefNode(nowReading);
    404                 result.setProductionTag(14);
     388                result.setProductionTag(13);
    405389                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    406390                expect(Lextant.FUNCTION);
     
    445429                boolean allowCompression = true;
    446430                ASTNode result = new ASTNode(nowReading);
    447                 result.setProductionTag(15);
     431                result.setProductionTag(14);
    448432                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    449433                {
     
    465449                boolean allowCompression = true;
    466450                ASTNode result = new ParameterListNode(nowReading);
    467                 result.setProductionTag(16);
     451                result.setProductionTag(15);
    468452                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    469453                {
     
    493477                boolean allowCompression = true;
    494478                ASTNode result = new ASTNode(nowReading);
    495                 result.setProductionTag(17);
     479                result.setProductionTag(16);
    496480                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    497481                {
     
    513497                boolean allowCompression = true;
    514498                ASTNode result = new ParameterNode(nowReading);
    515                 result.setProductionTag(18);
     499                result.setProductionTag(17);
    516500                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    517501                {
     
    538522                boolean allowCompression = true;
    539523                ASTNode result = new ASTNode(nowReading);
    540                 result.setProductionTag(19);
     524                result.setProductionTag(18);
    541525                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    542526                {
     
    558542                boolean allowCompression = true;
    559543                ASTNode result = new ASTNode(nowReading);
    560                 result.setProductionTag(20);
     544                result.setProductionTag(19);
    561545                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    562546                {
     
    578562                boolean allowCompression = true;
    579563                ASTNode result = new ASTNode(nowReading);
    580                 result.setProductionTag(21);
     564                result.setProductionTag(20);
    581565                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    582566                {
     
    598582                boolean allowCompression = true;
    599583                ASTNode result = new ASTNode(nowReading);
    600                 result.setProductionTag(22);
     584                result.setProductionTag(21);
    601585                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    602586                if( nowReading.isLextant(Lextant.BITBLOCK, Lextant.BITFIELD, Lextant.BOOL, Lextant.INT, Lextant.STRUCT, Lextant.VOID) ) {
     
    651635                boolean allowCompression = true;
    652636                ASTNode result = new FuncCallOrAssignStmtNode(nowReading);
    653                 result.setProductionTag(23);
     637                result.setProductionTag(22);
    654638                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    655639                {
     
    677661                boolean allowCompression = true;
    678662                ASTNode result = new IdisaFuncCallArgListNode(nowReading);
    679                 result.setProductionTag(24);
     663                result.setProductionTag(23);
    680664                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    681665                if( nowReading.isLextant(Lextant.LROUND) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    707691                boolean allowCompression = true;
    708692                ASTNode result = new AssignOperatorNode(nowReading);
    709                 result.setProductionTag(25);
     693                result.setProductionTag(24);
    710694                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    711695                expect(Lextant.ASSIGN);
     
    723707                boolean allowCompression = true;
    724708                ASTNode result = new AssignNode(nowReading);
    725                 result.setProductionTag(26);
     709                result.setProductionTag(25);
    726710                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    727711                {
     
    749733                boolean allowCompression = true;
    750734                ASTNode result = new IfStmtNode(nowReading);
    751                 result.setProductionTag(27);
     735                result.setProductionTag(26);
    752736                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    753737                expect(Lextant.IF);
     
    785769                boolean allowCompression = true;
    786770                ASTNode result = new WhileStmtNode(nowReading);
    787                 result.setProductionTag(28);
     771                result.setProductionTag(27);
    788772                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    789773                expect(Lextant.WHILE);
     
    813797                boolean allowCompression = true;
    814798                ASTNode result = new ReturnStmtNode(nowReading);
    815                 result.setProductionTag(29);
     799                result.setProductionTag(28);
    816800                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    817801                expect(Lextant.RETURN);
     
    837821                boolean allowCompression = true;
    838822                ASTNode result = new LocalVarDeclNode(nowReading);
    839                 result.setProductionTag(30);
     823                result.setProductionTag(29);
    840824                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    841825                {
     
    876860                boolean allowCompression = true;
    877861                ASTNode result = new ASTNode(nowReading);
    878                 result.setProductionTag(31);
     862                result.setProductionTag(30);
    879863                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    880864                {
     
    896880                boolean allowCompression = true;
    897881                ASTNode result = new BlockStmtNode(nowReading);
    898                 result.setProductionTag(32);
     882                result.setProductionTag(31);
    899883                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    900884                expect(Lextant.LCURLY);
     
    920904                boolean allowCompression = true;
    921905                ASTNode result = new ASTNode(nowReading);
    922                 result.setProductionTag(33);
     906                result.setProductionTag(32);
    923907                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    924908                if( nowReading.isLextant(Lextant.LROUND) ) {
     
    984968                boolean allowCompression = true;
    985969                ASTNode result = new ASTNode(nowReading);
    986                 result.setProductionTag(34);
     970                result.setProductionTag(33);
    987971                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    988972                if( (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    10161000                boolean allowCompression = true;
    10171001                ASTNode result = new IntegerConstantNode(nowReading);
    1018                 result.setProductionTag(35);
     1002                result.setProductionTag(34);
    10191003                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10201004                if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     
    10421026                boolean allowCompression = true;
    10431027                ASTNode result = new StringConstantNode(nowReading);
    1044                 result.setProductionTag(36);
     1028                result.setProductionTag(35);
    10451029                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10461030                if( (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    10721056                boolean allowCompression = true;
    10731057                ASTNode result = new CompoundIdentifierNode(nowReading);
    1074                 result.setProductionTag(37);
     1058                result.setProductionTag(36);
    10751059                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10761060                {
     
    11011085                boolean allowCompression = true;
    11021086                ASTNode result = new IdentifierNode(nowReading);
    1103                 result.setProductionTag(38);
     1087                result.setProductionTag(37);
    11041088                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11051089                if( !(nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     
    11201104                boolean allowCompression = true;
    11211105                ASTNode result = new FuncCallNode(nowReading);
    1122                 result.setProductionTag(39);
     1106                result.setProductionTag(38);
    11231107                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11241108                result.setToken(nowReading);
     
    11391123                boolean allowCompression = true;
    11401124                ASTNode result = new FuncCallArgListNode(nowReading);
    1141                 result.setProductionTag(40);
     1125                result.setProductionTag(39);
    11421126                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11431127                if( nowReading.isLextant(Lextant.LROUND) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    11691153                boolean allowCompression = true;
    11701154                ASTNode result = new IdisaFuncCallNode(nowReading);
    1171                 result.setProductionTag(41);
     1155                result.setProductionTag(40);
    11721156                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11731157                result.setToken(nowReading);
     
    11991183                boolean allowCompression = true;
    12001184                ASTNode result = new FieldWidthNode(nowReading);
    1201                 result.setProductionTag(42);
     1185                result.setProductionTag(41);
    12021186                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12031187                {
     
    12191203                boolean allowCompression = true;
    12201204                ASTNode result = new ASTNode(nowReading);
    1221                 result.setProductionTag(43);
     1205                result.setProductionTag(42);
    12221206                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12231207                if( nowReading.isLextant(Lextant.BITBLOCK, Lextant.BOOL, Lextant.INT, Lextant.VOID) ) {
     
    12581242                boolean allowCompression = true;
    12591243                ASTNode result = new ASTNode(nowReading);
    1260                 result.setProductionTag(44);
     1244                result.setProductionTag(43);
    12611245                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12621246                if( nowReading.isLextant(Lextant.INT) ) {
     
    13041288                boolean allowCompression = true;
    13051289                ASTNode result = new IntTypeNode(nowReading);
    1306                 result.setProductionTag(45);
     1290                result.setProductionTag(44);
    13071291                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13081292                expect(Lextant.INT);
     
    13201304                boolean allowCompression = true;
    13211305                ASTNode result = new VoidTypeNode(nowReading);
    1322                 result.setProductionTag(46);
     1306                result.setProductionTag(45);
    13231307                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13241308                expect(Lextant.VOID);
     
    13361320                boolean allowCompression = true;
    13371321                ASTNode result = new BoolTypeNode(nowReading);
    1338                 result.setProductionTag(47);
     1322                result.setProductionTag(46);
    13391323                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13401324                expect(Lextant.BOOL);
     
    13521336                boolean allowCompression = true;
    13531337                ASTNode result = new BitBlockTypeNode(nowReading);
    1354                 result.setProductionTag(48);
     1338                result.setProductionTag(47);
    13551339                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13561340                expect(Lextant.BITBLOCK);
     
    13681352                boolean allowCompression = true;
    13691353                ASTNode result = new BitFieldTypeNode(nowReading);
    1370                 result.setProductionTag(49);
     1354                result.setProductionTag(48);
    13711355                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13721356                expect(Lextant.BITFIELD);
     
    13931377                boolean allowCompression = true;
    13941378                ASTNode result = new IntegerConstantNode(nowReading);
    1395                 result.setProductionTag(50);
     1379                result.setProductionTag(49);
    13961380                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13971381                if( nowReading.isLextant(Lextant.LANGLE) ) {
     
    14291413                boolean allowCompression = true;
    14301414                ASTNode result = new StructTypeNode(nowReading);
    1431                 result.setProductionTag(51);
     1415                result.setProductionTag(50);
    14321416                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    14331417                expect(Lextant.STRUCT);
     
    14501434                boolean allowCompression = true;
    14511435                ASTNode result = new ASTNode(nowReading);
    1452                 result.setProductionTag(52);
     1436                result.setProductionTag(51);
    14531437                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    14541438                {
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Accessors.java

    r3233 r3258  
    9090        // Kernel Definition
    9191        ////////////////////////////////////////////////////////////////////////////
    92         public static InitBlockNode initBlockNode(InitDefNode node) {
    93                 return (InitBlockNode) node.child(0);
    94         }
     92
    9593       
    9694        ////////////////////////////////////////////////////////////////////////////
  • proto/pabloj/trunk/src/toolchain/pabloB/codeGenerator/visitors/Unparser.java

    r3193 r3258  
    9191                String kernelName = childResults.get(0).getResultVarName();
    9292               
    93                 CodeStore initDef = childResults.get(1);
     93
     94//              CodeStore initDef = childResults.get(1); // KH: breakage
    9495               
    9596                CodeStore funcDefCodeStore = childResults.get(2);
     
    99100               
    100101                code.indentedFormattedLine("%s()", kernelName);
    101                 code.addAll(initDef, 0);
     102               
     103                code.addLine("{}");
     104//              code.addAll(initDef, 0); // KH: breakage
    102105               
    103106                funcDefCodeStore.prependToFirst("IDISA_INLINE ");
     
    129132        // Kernel Initialization
    130133        ////////////////////////////////////////////////////////////////////////////
    131         public CodeStore visitLeave(InitDefNode node, List<CodeStore> childResults) {
     134/*     
     135        public CodeStore visitLeave(StateDefNode node, List<CodeStore> childResults) {
    132136                CodeStore code = new CodeStore();
    133137               
     
    143147               
    144148                return code;
    145         }       
    146 
    147         public CodeStore visitLeave(InitBlockNode node, List<CodeStore> childResults) {
     149        }
     150                */
     151
     152/*      public CodeStore visitLeave(InitBlockNode node, List<CodeStore> childResults) {
    148153                CodeStore code = new CodeStore();
    149154               
     
    159164                return code;
    160165        }
     166*/     
    161167        /* TODO - Update init section and remove
    162168        public CodeStore visitLeave(StateIdentifierNode node, List<CodeStore> childResults) {           
Note: See TracChangeset for help on using the changeset viewer.