Ignore:
Timestamp:
May 27, 2013, 1:54:27 PM (6 years ago)
Author:
ksherdy
Message:

Sweeping changes to sync branch with trunk.

Location:
proto/pabloj/branches/refactor-experimental/src/toolchain
Files:
1 added
9 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloB/ast/Accessors.java

    r3099 r3192  
    1010import java.util.List;
    1111
    12 
    1312import pabloB.ast.*;
    14 import toolchain.pabloB.ast.Accessors;
    1513
    1614public class Accessors {
     
    2826        // Program
    2927        ////////////////////////////////////////////////////////////////////////////
     28
     29        public static List<StructDeclNode> structDeclNodes(ProgramNode node) {
     30               
     31                List<StructDeclNode> structTypeDecls = new ArrayList<StructDeclNode>();
     32               
     33                for(ASTNode child: node.getChildren()) {
     34                        if(child instanceof StructDeclNode) {
     35                                structTypeDecls.add((StructDeclNode)child);
     36                        }
     37                }
     38               
     39                return structTypeDecls;
     40        }
    3041               
    3142        public static List<KernelDefNode> kernelDefNodes(ProgramNode node) {
     
    3950        }
    4051       
    41         public static List<StructTypeNode> structTypeDeclNodes(ProgramNode node) {
    42                 List<StructTypeNode> list = new ArrayList<StructTypeNode>();
    43                 for(ASTNode child: node.getChildren()) {
    44                         if (child instanceof TypeDeclNode) {
    45                                 ASTNode type = child.child(0);
    46                                 if(type instanceof StructTypeNode) {
    47                                         list.add((StructTypeNode)type);
    48                                 }
    49                         }
    50                 }
    51                 return list;
    52         }
    53        
    54         ////////////////////////////////////////////////////////////////////////////
    55         // Kernel Definition
    56         ////////////////////////////////////////////////////////////////////////////
    57        
     52        ////////////////////////////////////////////////////////////////////////////
     53        // Kernel
     54        ////////////////////////////////////////////////////////////////////////////
     55               
    5856        ////////////////////////////////////////////////////////////////////////////
    5957        // Initialization
     
    7472       
    7573        public static boolean hasOptFuncDef(KernelDefNode node) {
    76                 if(node.nChildren() > 1 && (node.child(2) instanceof FuncDefNode)) {
     74                if(node.nChildren() > 2 && (node.child(3) instanceof FuncDefNode)) {
    7775                        return true;
    7876                }
     
    178176
    179177        ////////////////////////////////////////////////////////////////////////////
    180         // Integer Constant
    181         ////////////////////////////////////////////////////////////////////////////           
    182         public static String streamConstantLexeme(StreamConstantNode node) {
    183                 return node.getToken().getLexeme();
    184         }               
    185        
    186         ////////////////////////////////////////////////////////////////////////////
    187178        // String Constant
    188179        ////////////////////////////////////////////////////////////////////////////           
     
    232223       
    233224        ////////////////////////////////////////////////////////////////////////////
     225        // StructDeclNode
     226        ////////////////////////////////////////////////////////////////////////////
     227        public static String structName(StructDeclNode node) {
     228        String name = new String();
     229        name = Accessors.name(node.child(0));
     230        return name;
     231        }
     232
     233        public static StructDeclBodyNode structBody(StructDeclNode node) {
     234                ASTNode child = node.child(1);
     235                assert child instanceof StructDeclBodyNode;
     236        return (StructDeclBodyNode) child;
     237        }       
     238
     239//  Deprecated 
     240//     
     241//      public static boolean hasStructBody(StructTypeNode node) {
     242//              if (node.nChildren() > 1) {
     243//                      ASTNode child = node.child(1);
     244//                      assert child instanceof StructTypeBodyNode;
     245//                      return true;
     246//              }
     247//              return false;
     248//      }               
     249       
     250        ////////////////////////////////////////////////////////////////////////////
    234251        // StructTypeNode
    235252        ////////////////////////////////////////////////////////////////////////////
     
    238255        name = Accessors.name(node.child(0));
    239256        return name;
    240         }
    241 
    242         public static StructTypeBodyNode structBody(StructTypeNode node) {
    243                 ASTNode child = node.child(1);
    244                 assert child instanceof StructTypeBodyNode;
    245         return (StructTypeBodyNode) child;
    246         }       
    247        
    248         public static boolean hasStructBody(StructTypeNode node) {
    249                 if (node.nChildren() > 1) {
    250                         ASTNode child = node.child(1);
    251                         assert child instanceof StructTypeBodyNode;
    252                         return true;
    253                 }
    254                 return false;
    255         }               
    256 
     257        }       
     258
     259        public static String structTypeLexeme(StructTypeNode node) {           
     260                return node.getToken().getLexeme();
     261        }       
     262               
    257263        ////////////////////////////////////////////////////////////////////////////
    258264        // Field Width
     
    275281                return node.getToken().getLexeme();
    276282        }       
    277 
    278         ////////////////////////////////////////////////////////////////////////////
    279         // Stream Type
    280         ////////////////////////////////////////////////////////////////////////////   
    281         public static String streamLexeme(StreamTypeNode node) {               
    282                 return "BitBlock"; // TODO - remove
    283         }       
    284283       
    285284        ////////////////////////////////////////////////////////////////////////////
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloB/ast/Generators.java

    r3099 r3192  
    99
    1010package toolchain.pabloB.ast;
    11 
    12 import java.util.ArrayList;
    1311import java.util.List;
    14 
    15 
    1612
    1713import pabloB.ast.*;
     
    3531        // PabloS2PabloB Token Conversion 
    3632        ////////////////////////////////////////////////////////////////////////////
    37         private static final String LEXICAL_CONTEXT = "main";   
     33       
     34        public static final String LEXICAL_CONTEXT = "main";   
    3835       
    3936        public static pabloB.tokens.Token makePabloBToken(pabloS.tokens.Token sToken) {
     
    7067                       
    7168                } else if (sToken instanceof pabloS.tokens.LextantToken) {
    72 
     69                       
    7370                        bToken = pabloB.tokens.LextantToken.make(makePabloBTextLocation(sToken.getLocation()),
    7471                                                                                                        sToken.getLexeme(),
     
    104101        }
    105102
    106         private static pabloB.inputHandler.TextLocation makePabloBTextLocation(pabloS.inputHandler.TextLocation sTextLocation) {
     103        public static pabloB.inputHandler.TextLocation makePabloBTextLocation(pabloS.inputHandler.TextLocation sTextLocation) {
    107104                pabloB.inputHandler.TextLocation bTextLocation = new pabloB.inputHandler.TextLocation(sTextLocation.getFilename(),
    108105                                                                                                                                                                                                sTextLocation.getLineNumber(),
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloB/lang/carrySet/CarrySetBuiltins2C.java

    r3134 r3192  
    2323        for(CarrySetBuiltins op : CarrySetBuiltins.values()) {
    2424                if(!carry2CCode.containsKey(op)) {
    25                                 throw new RuntimeException("CarrySet to C code mapping unimplemented :" + CarrySetBuiltins2C.class.getSimpleName());
     25                        throw new RuntimeException("CarrySet to C code mapping unimplemented :" + CarrySetBuiltins2CPP.class.getSimpleName());
    2626                }
    2727        }
    2828    }
    2929
    30         @Override
    3130        public String getCode(CarrySetBuiltins op) {
    3231                return carry2CCode.get(op);
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/ast/Accessors.java

    r3164 r3192  
    88
    99import pabloS.ast.*;
    10 
    1110import java.util.ArrayList;
    1211import java.util.List;
     
    2423        ////////////////////////////////////////////////////////////////////////////
    2524
    26         public static List<StructTypeNode> structTypeDeclNodes(ProgramNode node) {
    27                
    28                 List<StructTypeNode> structTypeDecls = new ArrayList<StructTypeNode>();
     25        ////////////////////////////////////////////////////////////////////////////
     26        // Program
     27        ////////////////////////////////////////////////////////////////////////////
     28               
     29        public static List<StructDeclNode> structDeclNodes(ProgramNode node) {
     30               
     31                List<StructDeclNode> structTypeDecls = new ArrayList<StructDeclNode>();
    2932               
    3033                for(ASTNode child: node.getChildren()) {
    31                         if(child instanceof StructTypeNode) {
    32                                 structTypeDecls.add((StructTypeNode)child);
     34                        if(child instanceof StructDeclNode) {
     35                                structTypeDecls.add((StructDeclNode)child);
    3336                        }
    3437                }
     
    277280
    278281        ////////////////////////////////////////////////////////////////////////////
     282        // StructDeclNode
     283        ////////////////////////////////////////////////////////////////////////////
     284        public static String structName(StructDeclNode node) {
     285        String name = new String();
     286        name = Accessors.name(node.child(0));
     287        return name;
     288        }
     289
     290        public static StructDeclBodyNode structBody(StructDeclNode node) {
     291                ASTNode child = node.child(1);
     292                assert child instanceof StructDeclBodyNode;
     293        return (StructDeclBodyNode) child;
     294        }       
     295       
     296//      public static boolean hasStructBody(StructTypeNode node) {
     297//              if (node.nChildren() > 1) {
     298//                      ASTNode child = node.child(1);
     299//                      assert child instanceof StructTypeBodyNode;
     300//                      return true;
     301//              }
     302//              return false;
     303//      }       
     304       
     305        public static String structMemberName(StructMemberNode node) {
     306        return Accessors.name(node.child(1));
     307        }       
     308
     309        ////////////////////////////////////////////////////////////////////////////
    279310        // StructTypeNode
    280311        ////////////////////////////////////////////////////////////////////////////
    281        
    282312        public static String structName(StructTypeNode node) {
    283313        String name = new String();
     
    285315        return name;
    286316        }
    287 
    288         public static StructTypeBodyNode structBody(StructTypeNode node) {
    289                 ASTNode child = node.child(1);
    290                 assert child instanceof StructTypeBodyNode;
    291         return (StructTypeBodyNode) child;
    292         }       
    293        
    294         public static boolean hasStructBody(StructTypeNode node) {
    295                 if (node.nChildren() > 1) {
    296                         ASTNode child = node.child(1);
    297                         assert child instanceof StructTypeBodyNode;
    298                         return true;
    299                 }
    300                 return false;
    301         }       
    302        
    303         public static String structMemberName(StructMemberNode node) {
    304         return Accessors.name(node.child(1));
    305         }       
     317       
     318        public static String structTypeLexeme(StructTypeNode node) {           
     319                return node.getToken().getLexeme();
     320        }               
    306321       
    307322        ////////////////////////////////////////////////////////////////////////////
     
    332347                return node.getToken().getLexeme();
    333348        }                       
    334 
    335349       
    336350}
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/ast/Generators.java

    r3133 r3192  
    127127       
    128128       
    129        
     129        public static CompoundIdentifierNode makeCompoundIdentifierNode(String pckage, String name, Locator locator) {
     130                return makeCompoundIdentifierNode(new String [] {pckage, name}, locator);
     131        }
    130132       
    131133        /** Makes a new CompoundIdentifierNode with an array of identifier strings and and the TextLocation taken from locator.
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/Transformer.java

    r3133 r3192  
    7474                decoratedTree = CarryIntroXFormer.apply(decoratedTree, getBuiltinEncoder(), getCarrySet2Lang(), finalBlockMode);
    7575                decoratedTree = ConvertBitwiseBooleanToIDISACalls.apply(decoratedTree);
    76                 decoratedTree = InitializeStreamDefaults.apply(decoratedTree);
     76                //decoratedTree = InitializeStreamDefaults.apply(decoratedTree);
    7777               
    7878                return decoratedTree;
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/InitializeStreamDefaults.java

    r3163 r3192  
    6363
    6464                private int fieldWidth(StreamTypeNode streamType) {
    65                                 String lexeme = Accessors.lexeme(streamType);
    66                                 return Integer.parseInt(lexeme);
     65                                return streamType.getFieldWidth();
    6766                }
    6867               
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/PabloS2PabloBXFormer.java

    r3163 r3192  
    88
    99import java.lang.reflect.Constructor;
     10import java.util.HashMap;
    1011import java.util.LinkedHashMap;
    1112import java.util.List;
     
    3637       
    3738        private SymbolTable pabloSSymbolTable;
    38 
    39        
    4039        private CarrySetEncoder carrySetEncoder;
    4140       
     
    5554    }
    5655
    57     public pabloB.ast.ASTNode XForm(pabloS.ast.ProgramNode decoratedASTTree) {
     56    /*   
     57        public pabloB.ast.ASTNode XForm(pabloS.ast.ProgramNode decoratedASTTree) {
    5858                return XForm(decoratedASTTree, decoratedASTTree);
    5959    }
     60    */
    6061     
    6162    public pabloB.ast.ASTNode XForm(pabloS.ast.ProgramNode decoratedASTTree, pabloS.ast.ProgramNode optDecoratedASTTree) {
    6263               
    63         this.decoratedASTTree = decoratedASTTree;
    64                 this.optDecoratedASTTree = optDecoratedASTTree;
    65        
    66                 // pabloS to pabloB AST builders (all nodes)
    67                 pabloB.ast.ASTNode bASTTree = this.decoratedASTTree.accept(new pabloBASTBuilder());
    68                 pabloB.ast.ASTNode bOptASTTree = this.optDecoratedASTTree.accept(new pabloBASTBuilder());
     64        this.decoratedASTTree           = decoratedASTTree;
     65                this.optDecoratedASTTree        = optDecoratedASTTree;
     66       
     67                pabloB.ast.ASTNode bASTTree     = this.decoratedASTTree.accept(new pabloBASTBuilder());
     68                pabloB.ast.ASTNode bOptASTTree  = this.optDecoratedASTTree.accept(new pabloBASTBuilder());
    6969               
    7070                // map function names to function definition nodes             
    71                 Map<String, pabloB.ast.FuncDefNode> map = funcDefMapBuilder(bASTTree);
    72                 Map<String, pabloB.ast.FuncDefNode> optMap = funcDefMapBuilder(bOptASTTree);
     71                Map<String, pabloB.ast.FuncDefNode> map         = makeFuncDefMap(bASTTree);
     72                Map<String, pabloB.ast.FuncDefNode> optMap      = makeFuncDefMap(bOptASTTree);
    7373               
    7474                for (Map.Entry<String, pabloB.ast.FuncDefNode> entry : map.entrySet())
    7575                {       
    76                         pabloB.ast.FuncDefNode funcDefNode = entry.getValue();
    77                         pabloB.ast.FuncDefNode optFuncDefNode = optMap.get(entry.getKey());
    78                
    79                         pabloB.tokens.Token locationToken = funcDefNode.getToken();
     76                        pabloB.ast.FuncDefNode funcDefNode                      = entry.getValue();
     77                        pabloB.ast.FuncDefNode optFuncDefNode           = optMap.get(entry.getKey());
     78               
     79                        pabloB.tokens.Token locationToken                       = funcDefNode.getToken();
    8080                       
    8181                        pabloB.ast.IdentifierNode doBlockIdentifier = Generators.makeIdentifierNode(DO_BLOCK, locationToken);
     
    140140                                                                                                       
    141141                                                        toolchain.pabloB.ast.Accessors.initBlockNode(initDefNode).appendChild(setCarryFuncCall);
    142                                                        
    143142                                        }
    144143                                }
     
    162161                return bASTTree;
    163162    }
    164      
     163
     164    /*
     165     * Recursively builds function name to function definition node map via DFS.
     166     */
     167        private static Map<String, pabloB.ast.FuncDefNode> makeFuncDefMap(pabloB.ast.ASTNode node) {
     168
     169                if(node instanceof pabloB.ast.FuncDefNode) {
     170                        Map<String, pabloB.ast.FuncDefNode> map = new HashMap<String, pabloB.ast.FuncDefNode>();
     171                        String key = toolchain.pabloB.ast.Accessors.funcName((pabloB.ast.FuncDefNode)node);
     172                        pabloB.ast.FuncDefNode value = (pabloB.ast.FuncDefNode)node;
     173                        map.put(key, value);
     174                        return map;
     175                }
     176               
     177                Map<String, pabloB.ast.FuncDefNode> map = new HashMap<String, pabloB.ast.FuncDefNode>();
     178               
     179                for(pabloB.ast.ASTNode child : node.getChildren()) {
     180                        map.putAll(makeFuncDefMap(child));
     181                }
     182               
     183                return map;     
     184        }   
     185   
    165186    /*
    166187     * pabloS to pabloB node builder
    167188     */
    168189        private class pabloBASTBuilder extends Default<pabloB.ast.ASTNode> {
    169                 // first crack at reflection version.
     190               
     191                // General case.
    170192                @Override
    171193                public pabloB.ast.ASTNode defaultVisitLeave(pabloS.ast.ASTNode node, List<pabloB.ast.ASTNode> childResults) {
     
    187209                }
    188210               
     211                // Special cases.
     212               
     213                // pabloS stream type to pabloB bitblock type 
     214                //
     215                // TODO consider field width attributes
     216                public pabloB.ast.ASTNode visitLeave(pabloS.ast.StreamTypeNode node, List<pabloB.ast.ASTNode> childResults) {
     217                       
     218                        String lexeme = pabloB.lexicalAnalyzer.Lextant.BITBLOCK.getPrimaryLexeme();
     219                       
     220                        pabloB.tokens.Token bToken = pabloB.tokens.LextantToken.make(Generators.makePabloBTextLocation(node.getToken().getLocation()),
     221                                        lexeme,
     222                                        pabloB.lexicalAnalyzer.Lextant.forLexeme(lexeme, Generators.LEXICAL_CONTEXT)); 
     223                       
     224                        pabloB.ast.ASTNode bNode = new pabloB.ast.BitBlockTypeNode(bToken);
     225                        appendChildResults(bNode, childResults);
     226                        return bNode;
     227                }
     228               
     229                /*
    189230                public pabloB.ast.ASTNode visitLeave(pabloS.ast.AssignNode node, List<pabloB.ast.ASTNode> childResults) {
    190231                        pabloB.ast.ASTNode bNode = new pabloB.ast.AssignNode(Generators.makePabloBToken(node.getToken()));
     
    192233                        return bNode;
    193234                }
    194 
    195                 /*
    196                 public void visitEnter(AssignOperatorNode node) {
    197                         defaultVisitEnter(node);
    198                 }
    199                 */
    200                
    201                 /*// - Deprecated
    202                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.AssignOperatorNode node, List<pabloB.ast.ASTNode> childResults) {
    203                         pabloB.ast.ASTNode bNode = new pabloB.ast.AssignOperatorNode(Generators.makePabloBToken(node.getToken()));
    204                         appendChildResults(bNode, childResults);
    205                         return bNode;
    206                 }
    207                 */
    208 
    209                 /*// - Deprecated
    210                 public void visitEnter(BinaryOperatorNode node) {
    211                         defaultVisitEnter(node);
    212                 }
    213                 */
    214                
    215                 /*// - Deprecated
    216                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.BinaryOperatorNode node, List<pabloB.ast.ASTNode> childResults) {
    217                         pabloB.ast.ASTNode bNode = new pabloB.ast.BinaryOperatorNode(Generators.makePabloBToken(node.getToken()));                     
    218                         appendChildResults(bNode, childResults);
    219                         return bNode;
    220                 }
    221                 */
    222 
    223                 /*
    224                 public void visitEnter(BlockStmtNode node) {
    225                         defaultVisitEnter(node);
    226                 }
    227                 */
    228                
     235                               
    229236                public pabloB.ast.ASTNode visitLeave(pabloS.ast.BlockStmtNode node, List<pabloB.ast.ASTNode> childResults) {
    230237                        pabloB.ast.ASTNode bNode = new pabloB.ast.BlockStmtNode(Generators.makePabloBToken(node.getToken()));
     
    233240                }
    234241
    235                 /*
    236                 public void visitEnter(CompoundIdentifierNode node) {
    237                         defaultVisitEnter(node);
    238                 }
    239                 */
    240                
    241242                public pabloB.ast.ASTNode visitLeave(pabloS.ast.CompoundIdentifierNode node, List<pabloB.ast.ASTNode> childResults) {
    242243                        pabloB.ast.ASTNode bNode = new pabloB.ast.CompoundIdentifierNode(Generators.makePabloBToken(node.getToken()));
     
    244245                        return bNode;
    245246                }
    246 
    247                 /*
    248                 public void visitEnter(EpsilonNode node) {
    249                         defaultVisitEnter(node);
    250                 }
    251                 */
    252247               
    253248                public pabloB.ast.ASTNode visitLeave(pabloS.ast.EpsilonNode node, List<pabloB.ast.ASTNode> childResults) {
     
    256251                        return bNode;
    257252                }
    258 
    259                 /*
    260                 public void visitEnter(ErrorNode node) {
    261                         defaultVisitEnter(node);
    262                 }
    263                 */
    264253               
    265254                public pabloB.ast.ASTNode visitLeave(pabloS.ast.ErrorNode node, List<pabloB.ast.ASTNode> childResults) {
     
    268257                        return bNode;
    269258                }
    270 
    271                 /* - Deprecated
    272                 public void visitEnter(FieldWidthNode node) {
    273                         defaultVisitEnter(node);
    274                 }
    275                 */
    276                
    277                 /*
    278                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.FieldWidthNode node, List<pabloB.ast.ASTNode> childResults) {
    279                         pabloB.ast.ASTNode bNode = new pabloB.ast.FieldWidthNode(Generators.makePabloBToken(node.getToken()));
    280                         appendChildResults(bNode, childResults);
    281                         return bNode;
    282                 }
    283                 */
    284 
    285                 /*
    286                 public void visitEnter(FuncCallArgListNode node) {
    287                         defaultVisitEnter(node);
    288                 }
    289                 */
    290259               
    291260                public pabloB.ast.ASTNode visitLeave(pabloS.ast.FuncCallArgListNode node, List<pabloB.ast.ASTNode> childResults) {
     
    293262                        appendChildResults(bNode, childResults);
    294263                        return bNode;
    295                 }
    296 
    297                 /*
    298                 public void visitEnter(FuncCallNode node) {
    299                         defaultVisitEnter(node);
    300264                }
    301265                */
     
    363327                        return bNode;
    364328                }
    365 
     329               
    366330                /*
    367                 public void visitEnter(FuncCallOrAssignStmtNode node) {
    368                         defaultVisitEnter(node);
    369                 }
    370                 */
    371 
    372                
    373331                public pabloB.ast.ASTNode visitLeave(pabloS.ast.FuncCallOrAssignStmtNode node, List<pabloB.ast.ASTNode> childResults) {
    374332                        pabloB.ast.ASTNode bNode = new pabloB.ast.FuncCallOrAssignStmtNode(Generators.makePabloBToken(node.getToken()));
     
    376334                        return bNode;
    377335                }
    378 
    379                 /*
    380                 public void visitEnter(FuncDefNode node) {
    381                         defaultVisitEnter(node);
    382                 }
    383                 */
    384336                       
    385337                public pabloB.ast.ASTNode visitLeave(pabloS.ast.FuncDefNode node, List<pabloB.ast.ASTNode> childResults) {
     
    389341                }
    390342
    391                 /*
    392                 public void visitEnter(IdentifierNode node) {
    393                         defaultVisitEnter(node);
    394                 }
    395                 */
    396                
    397343                public pabloB.ast.ASTNode visitLeave(pabloS.ast.IdentifierNode node, List<pabloB.ast.ASTNode> childResults) {
    398344                        pabloB.ast.ASTNode bNode = new pabloB.ast.IdentifierNode(Generators.makePabloBToken(node.getToken()));
     
    401347                }
    402348
    403                 /*
    404                 public void visitEnter(IfStmtNode node) {
    405                         defaultVisitEnter(node);
    406                 }
    407                 */
    408                
    409349                public pabloB.ast.ASTNode visitLeave(pabloS.ast.IfStmtNode node, List<pabloB.ast.ASTNode> childResults) {
    410350                        pabloB.ast.ASTNode bNode = new pabloB.ast.IfStmtNode(Generators.makePabloBToken(node.getToken()));
    411351                        appendChildResults(bNode, childResults);
    412352                        return bNode;
    413                 }
    414 
    415                 /*
    416                 public void visitEnter(IntegerConstantNode node) {
    417                         defaultVisitEnter(node);
    418353                }
    419354                */
     
    426361                        return bNode;
    427362                }
    428 
     363               
    429364                /*
    430                 public void visitEnter(StreamConstantNode node) {
    431                         defaultVisitEnter(node);
    432                 }
    433                 */
    434                
    435                 /*
    436                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.StreamConstantNode node, List<pabloB.ast.ASTNode> childResults) {
    437                         pabloB.ast.ASTNode bNode = new pabloB.ast.StreamConstantNode(Generators.makePabloBToken(node.getToken()));
    438                         int value = new Integer(bNode.getToken().getLexeme());
    439                         ((pabloB.ast.StreamConstantNode)bNode).setValue(value); // set integer constant value
    440                         appendChildResults(bNode, childResults);
    441                         return bNode;
    442                 }
    443                 */             
    444                
    445                 /*
    446                 public void visitEnter(LocalVarDeclNode node) {
    447                         defaultVisitEnter(node);
    448                 }
    449                 */
    450                
    451365                public pabloB.ast.ASTNode visitLeave(pabloS.ast.LocalVarDeclNode node, List<pabloB.ast.ASTNode> childResults) {
    452366                        pabloB.ast.ASTNode bNode = new pabloB.ast.LocalVarDeclNode(Generators.makePabloBToken(node.getToken()));
     
    454368                        return bNode;
    455369                }
    456                
    457                 /*
    458                 public void visitEnter(ParameterListNode node) {
    459                         defaultVisitEnter(node);
    460                 }
    461                 */
    462                
     370                               
    463371                public pabloB.ast.ASTNode visitLeave(pabloS.ast.ParameterListNode node, List<pabloB.ast.ASTNode> childResults) {
    464372                        pabloB.ast.ASTNode bNode = new pabloB.ast.ParameterListNode(Generators.makePabloBToken(node.getToken()));                       
     
    466374                        return bNode;
    467375                }
    468 
    469                 /*
    470                 public void visitEnter(ParameterNode node) {
    471                         defaultVisitEnter(node);
    472                 }
    473                 */
    474376               
    475377                public pabloB.ast.ASTNode visitLeave(pabloS.ast.ParameterNode node, List<pabloB.ast.ASTNode> childResults) {
     
    479381                }
    480382               
    481                 /*
    482                 public void visitEnter(ProgramNode node) {
    483                         defaultVisitEnter(node);
    484                 }
    485                 */
    486                
    487383                public pabloB.ast.ASTNode visitLeave(pabloS.ast.ProgramNode node, List<pabloB.ast.ASTNode> childResults) {
    488384                        pabloB.ast.ProgramNode bNode = new pabloB.ast.ProgramNode(Generators.makePabloBToken(node.getToken()));
     
    491387                }
    492388
    493                 /*
    494                 public void visitEnter(ReturnStmtNode node) {
    495                         defaultVisitEnter(node);
    496                 }
    497                 */
    498                
    499389                public pabloB.ast.ASTNode visitLeave(pabloS.ast.ReturnStmtNode node, List<pabloB.ast.ASTNode> childResults) {
    500390                        pabloB.ast.ASTNode bNode = new pabloB.ast.ReturnStmtNode(Generators.makePabloBToken(node.getToken()));
     
    502392                        return bNode;
    503393                }
    504 
    505                 /*
    506                 public void visitEnter(StreamTypeNode node) {
    507                         defaultVisitEnter(node);
    508                 }
    509                 */
    510                
    511                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.StreamTypeNode node, List<pabloB.ast.ASTNode> childResults) {
    512                         pabloB.ast.ASTNode bNode = new pabloB.ast.StreamTypeNode(Generators.makePabloBToken(node.getToken()));
    513                         appendChildResults(bNode, childResults);
    514                         return bNode;
    515                 }
    516 
    517                 /*
    518                 public void visitEnter(StringConstantNode node) {
    519                         defaultVisitEnter(node);
    520                 }
    521                 */
    522394               
    523395                public pabloB.ast.ASTNode visitLeave(pabloS.ast.StringConstantNode node, List<pabloB.ast.ASTNode> childResults) {
     
    526398                        return bNode;
    527399                }
    528 
    529                 /*
    530                 public void visitEnter(StructMemberNode node) {
    531                         defaultVisitEnter(node);
    532                 }
    533                 */
     400               
     401                public pabloB.ast.ASTNode visitLeave(pabloS.ast.PrimitiveTypeNode node, List<pabloB.ast.ASTNode> childResults) {
     402                        pabloB.ast.ASTNode bNode = new pabloB.ast.VoidTypeNode(Generators.makePabloBToken(node.getToken()));
     403                        appendChildResults(bNode, childResults);
     404                        return bNode;
     405                }
    534406               
    535407                public pabloB.ast.ASTNode visitLeave(pabloS.ast.StructMemberNode node, List<pabloB.ast.ASTNode> childResults) {
     
    539411                }
    540412
    541                 /*
    542                 public void visitEnter(StructTypeBodyNode node) {
    543                         defaultVisitEnter(node);
    544                 }
    545                 */
    546                
    547413                public pabloB.ast.ASTNode visitLeave(pabloS.ast.StructTypeBodyNode node, List<pabloB.ast.ASTNode> childResults) {
    548414                        pabloB.ast.ASTNode bNode = new pabloB.ast.StructTypeBodyNode(Generators.makePabloBToken(node.getToken()));
     
    550416                        return bNode;
    551417                }
    552 
    553                 /*
    554                 public void visitEnter(StructTypeNode node) {
    555                         defaultVisitEnter(node);
    556                 }
    557                 */
    558418               
    559419                public pabloB.ast.ASTNode visitLeave(pabloS.ast.StructTypeNode node, List<pabloB.ast.ASTNode> childResults) {
     
    562422                        return bNode;
    563423                }
    564 
    565                 /*
    566                 public void visitEnter(pabloB.ast.ASTNodeypeDeclNode node) {
    567                         defaultVisitEnter(node);
    568                 }
    569                 */
    570                
    571                 /*
    572                 public void visitEnter(TypeDefNode node) {
    573                         defaultVisitEnter(node);
    574                 }
    575                 */
    576                
    577                 /* //- Deprecated
    578                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.TypeDefNode node, List<pabloB.ast.ASTNode> childResults) {
    579                         throw new RuntimeException(node.getClass().toString() + ": node class not supported.");
    580                 }
    581                 */
    582 
    583                 /*
    584                 public void visitEnter(UnaryOperatorNode node) {
    585                         defaultVisitEnter(node);
    586                 }
    587                 */
    588                
    589                 /* //- Deprecated
    590                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.UnaryOperatorNode node, List<pabloB.ast.ASTNode> childResults) {
    591                         pabloB.ast.ASTNode bNode = new pabloB.ast.UnaryOperatorNode(Generators.makePabloBToken(node.getToken()));
    592                         appendChildResults(bNode, childResults);
    593                         return bNode;
    594                 }
    595                 */
    596                
    597                 /*
    598                 public void visitEnter(VoidType node) {
    599                         defaultVisitEnter(node);
    600                 }
    601                 */
    602                
    603                 /*
    604                 public void visitEnter(WhileStmtNode node) {
    605                         defaultVisitEnter(node);
    606                 }
    607                 */
    608                
     424                               
    609425                public pabloB.ast.ASTNode visitLeave(pabloS.ast.WhileStmtNode node, List<pabloB.ast.ASTNode> childResults) {
    610426                        pabloB.ast.ASTNode bNode = new pabloB.ast.WhileStmtNode(Generators.makePabloBToken(node.getToken()));
     
    612428                        return bNode;
    613429                }
    614                
     430                */
    615431        }       
    616 
    617 /*     
    618         private  class String2FuncDefNodeMapBuilder extends VoidVisitor.Default {
    619        
    620                 private pabloB.ast.ASTNode ASTTree;
    621 
    622                
    623                 public Map<String, ASTNode> streamFuncMap() {
    624                         return streamFuncMap;
    625                 }
    626                                
    627                 public void visitLeave(FuncDefNode node) {
    628                                                        
    629                         String name = Accessors.funcName(node);
    630                         name = Generators.capitalize(name);
    631                         IdentifierToken nameToken = IdentifierToken.make(LexicalType.IDENTIFIER,
    632                                                                                 node.getToken().getLocation(),
    633                                                                                 name);
    634                        
    635                         Accessors.funcIdentifier(node).setToken(nameToken);
    636                         streamFuncMap.put(name, node);                                 
    637                        
    638                 }               
    639         }       
    640 */
    641 
    642         private static Map<String, pabloB.ast.FuncDefNode> funcDefMapBuilder(pabloB.ast.ASTNode node) {
    643 
    644                 if(node instanceof pabloB.ast.FuncDefNode) {
    645                        
    646                         LinkedHashMap<String, pabloB.ast.FuncDefNode> linkedHashMap = new LinkedHashMap<String, pabloB.ast.FuncDefNode>();
    647                        
    648                         String key = toolchain.pabloB.ast.Accessors.funcName((pabloB.ast.FuncDefNode)node);
    649                         pabloB.ast.FuncDefNode value = (pabloB.ast.FuncDefNode)node;
    650                         linkedHashMap.put(key, value);
    651                         return linkedHashMap;
    652                 }
    653                
    654                 LinkedHashMap<String, pabloB.ast.FuncDefNode> linkedHashMap = new LinkedHashMap<String, pabloB.ast.FuncDefNode>();
    655                
    656                 for(pabloB.ast.ASTNode child : node.getChildren()) {
    657                         linkedHashMap.putAll(funcDefMapBuilder(child));
    658                 }
    659                
    660                 return linkedHashMap;   
    661         }
    662        
    663        
    664         @SuppressWarnings("unused")
    665         private static pabloS.ast.FuncDefNode recursiveSearch(pabloS.ast.ASTNode node, String target) {
    666        
    667                 if(node instanceof pabloS.ast.ASTNode) {
    668                         if(toolchain.pabloS.ast.Accessors.funcName((pabloS.ast.FuncDefNode)node).equals(target)) {
    669                                 return (pabloS.ast.FuncDefNode)node;
    670                         }
    671                 }
    672                
    673                 pabloS.ast.FuncDefNode result = null;
    674                
    675                 for(pabloS.ast.ASTNode child : node.getChildren()) {
    676                         result = recursiveSearch(child, target);
    677                         if (result != null) {
    678                                 break;
    679                         }
    680                 }
    681                
    682                 return result; 
    683         }
    684432       
    685433        private static void appendChildResults(pabloB.ast.ASTNode bNode, List<pabloB.ast.ASTNode> childResults) {
     
    688436                }
    689437        }
     438       
     439        @SuppressWarnings("unused")
     440        private static pabloS.ast.FuncDefNode searchForFuncDefByName(pabloS.ast.ASTNode node, String name) {
     441       
     442                if(node instanceof pabloS.ast.FuncDefNode) {
     443                        if(toolchain.pabloS.ast.Accessors.funcName((pabloS.ast.FuncDefNode)node).equals(name)) {
     444                                return (pabloS.ast.FuncDefNode)node;
     445                        }
     446                }
     447               
     448                pabloS.ast.FuncDefNode result = null;
     449               
     450                for(pabloS.ast.ASTNode child : node.getChildren()) {
     451                        result = searchForFuncDefByName(child, name);
     452                        if (result != null) {
     453                                break;
     454                        }
     455                }
     456               
     457                return result; 
     458        }
     459       
    690460}
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/BuiltinTranslator.java

    r3143 r3192  
    55
    66import pabloS.ast.ASTNode;
     7import pabloS.ast.CompoundIdentifierNode;
    78import pabloS.ast.FuncCallNode;
    89import pabloS.ast.IntegerConstantNode;
     
    1819        ADVANCETHENSCANTHRU(PabloSBuiltins.ADVANCETHENSCANTHRU),
    1920        SPANUPTO(PabloSBuiltins.SPANUPTO),
    20         ADVANCETHENSCANTO(PabloSBuiltins.ADVANCETHENSCANTO, Action.SCANTO_ACTION),
    2121        INCLUSIVESPAN(PabloSBuiltins.INCLUSIVESPAN),
    2222        EXCLUSIVESPAN(PabloSBuiltins.EXCLUSIVESPAN),
    23         SCANTO(PabloSBuiltins.SCANTO, Action.SCANTO_ACTION),
    2423        SCANTOFIRST(PabloSBuiltins.SCANTOFIRST),                        // TODO: verify that this is basicAction and not scanToAction
    2524        ADVANCE32(PabloSBuiltins.ADVANCE32),
     
    2827        ATEOF(PabloSBuiltins.ATEOF, Action.ATEOF_ACTION),
    2928        INFILE(PabloSBuiltins.INFILE, Action.INFILE_ACTION),
    30         MASK(PabloSBuiltins.MASK, Action.MASK_ACTION);
     29        MASK(PabloSBuiltins.MASK, Action.MASK_ACTION),
     30        SCANTO(PabloSBuiltins.SCANTO, Action.SCANTO_ACTION),
     31        ADVANCETHENSCANTO(PabloSBuiltins.ADVANCETHENSCANTO, Action.ADVANCE_THEN_SCANTO_ACTION);
    3132
    3233        private enum Action {
    3334                CARRY_ACTION,
    3435                SCANTO_ACTION,
     36                ADVANCE_THEN_SCANTO_ACTION,
    3537                ADVANCEN_ACTION,
    3638                ATEOF_ACTION,
     
    4345       
    4446       
    45         private BuiltinTranslator(PabloSBuiltins builtin, BuiltinTranslator.Action actionSelector) {
     47        private BuiltinTranslator(PabloSBuiltins builtin, Action actionSelector) {
    4648                this.builtin = builtin;
    4749                this.usesAdvanceNCounter = (builtin.getCarryType()==CarryType.N);       
     
    7476        public void action(FuncCallNode node, Counter counter, Context context) {
    7577                switch(actionSelector) {
    76                 case CARRY_ACTION:     carryAction(node, counter, context);        break;
    77                 case SCANTO_ACTION:    scanToAction(node, counter, context);   break;
    78                 case ADVANCEN_ACTION:  advanceNAction(node, counter, context); break;
    79                 case ATEOF_ACTION:         atEOFAction(node, counter, context);    break;
    80                 case INFILE_ACTION:        infileAction(node, counter, context);   break;
    81                 case MASK_ACTION:          maskAction(node, counter, context);     break;
     78                case CARRY_ACTION:      carryAction(node, counter, context);    break;
     79                case ADVANCEN_ACTION:   advanceNAction(node, counter, context); break;
     80                case ATEOF_ACTION:              atEOFAction(node, counter, context);    break;
     81                case INFILE_ACTION:             infileAction(node, counter, context);   break;
     82                case MASK_ACTION:               maskAction(node, counter, context);         break;
     83               
     84                case SCANTO_ACTION:                 scanToAction(node, PabloSBuiltins.SCANTHRU, counter, context);   break;
     85                case ADVANCE_THEN_SCANTO_ACTION:    scanToAction(node, PabloSBuiltins.ADVANCETHENSCANTHRU, counter, context);   break;         
    8286                }
    8387        }
    84         public void carryAction(FuncCallNode node, Counter counter, Context context) {
     88       
     89        private void carryAction(FuncCallNode node, Counter counter, Context context) {
     90                carryAction(node, counter, context, getBuiltin());
     91        }
     92       
     93        public void carryAction(FuncCallNode node, Counter counter, Context context, PabloSBuiltins translation) {
    8594                List<ASTNode> arguments = Accessors.funcCallArgsList(node);
    8695               
    8796                replaceCallWithCarryCall(node,
    8897                                context.getCarrySetIdentifier(),
    89                                 context.getBuiltinEncoder().getCode(getBuiltin()),
     98                                context.getBuiltinEncoder().getCode(translation),
    9099                                arguments,
    91100                                counter.callOrMask(node, context),
     
    94103                counter.increment();
    95104        }               
    96         public void scanToAction(FuncCallNode node, Counter counter, Context context) {
     105        public void scanToAction(FuncCallNode node, PabloSBuiltins translation, Counter counter, Context context) {
    97106                ASTNode argument = Accessors.funcCallArg(node, 1);
     107                translateArgument(context, argument);
     108                ASTNode replacement = Generators.makeCompoundIdentifierNode(PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
     109                                                                                                                                                                        translation.pabloSName(), node);
    98110               
     111                node.replaceChild(Accessors.funcCallIdentifier(node), replacement);
     112                carryAction(node, counter, context, translation);
     113        }
     114        private void translateArgument(Context context, ASTNode argument) {
    99115                if(context.isFinalBlockMode()) {
    100                         ASTNode replacementNode = Generators.makeSIMDEOFMaskAndCNodeFuncCall(argument, context.getBuiltinEncoder());
    101                         argument.updateSelf(replacementNode);
     116                        ASTNode replacement = Generators.makeSIMDEOFMaskAndCNodeFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
     117                        argument.updateSelf(replacement);
    102118                }
    103119                else {
    104                         ASTNode replacementNode = Generators.makeSIMDNotFuncCall(argument, context.getBuiltinEncoder());
    105                         argument.updateSelf(replacementNode);
     120                        ASTNode replacement = Generators.makeSIMDNotFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
     121                        argument.updateSelf(replacement);                       
    106122                }
    107                
    108                 carryAction(node, counter, context);
    109123        }               
    110124        public void advanceNAction(FuncCallNode node, Counter counter, Context context) {
Note: See TracChangeset for help on using the changeset viewer.