Changeset 3768


Ignore:
Timestamp:
Mar 29, 2014, 11:28:45 PM (4 years ago)
Author:
ksherdy
Message:

Added filter to s2k.

Location:
proto/s2k/trunk/framework/src/toolchain
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • proto/s2k/trunk/framework/src/toolchain/b2k/ast/Accessors.java

    r3763 r3768  
    4848        ////////////////////////////////////////////////////////////////////////////
    4949                       
    50         public static FuncDefNode funcDefNode(KernelDefNode node) {
    51                 return (FuncDefNode) node.child(1);
     50        public static FilterDefNode funcDefNode(KernelDefNode node) {
     51                return (FilterDefNode) node.child(1);
    5252        }
    5353       
    5454        public static boolean hasFinalBlockFuncDef(KernelDefNode node) {
    55                 if(node.nChildren() > 3 && (node.child(3) instanceof FuncDefNode)) {
     55                if(node.nChildren() > 3 && (node.child(3) instanceof FilterDefNode)) {
    5656                        return true;
    5757                }
     
    5959        }       
    6060       
    61         public static FuncDefNode finalBlockFuncDefNode(KernelDefNode node) {
     61        public static FilterDefNode finalBlockFuncDefNode(KernelDefNode node) {
    6262                assert hasFinalBlockFuncDef(node);
    63                 return (FuncDefNode) node.child(2);
     63                return (FilterDefNode) node.child(2);
    6464        }
    6565       
     
    6868        }
    6969       
    70     public static FuncDefNode funcDefForName(ASTNode node, String name) {
    71 
    72         if(node instanceof FuncDefNode) {
     70    public static FilterDefNode funcDefForName(ASTNode node, String name) {
     71
     72        if(node instanceof FilterDefNode) {
    7373            if(name(node).equals(name)) {
    74                 return (FuncDefNode)node;
     74                return (FilterDefNode)node;
    7575            }
    7676        }
    7777
    78         FuncDefNode result = null;
     78        FilterDefNode result = null;
    7979
    8080        for(ASTNode child : node.getChildren()) {
     
    9595        // Function Definition
    9696        ////////////////////////////////////////////////////////////////////////////
    97         public static IdentifierNode funcIdentifier(FuncDefNode node) {
     97        public static IdentifierNode funcIdentifier(FilterDefNode node) {
    9898                return (IdentifierNode) node.child(0);
    9999        }
    100100       
    101         public static ASTNode nameNode(FuncDefNode node) {
     101        public static ASTNode nameNode(FilterDefNode node) {
    102102            return node.child(0);
    103103        }
    104         public static boolean hasParameters(FuncDefNode node) {
    105             return (node.nChildren()) > 1 && (node.child(1) instanceof ParameterListNode);
    106         }
    107         public static ParameterListNode parameterListNode(FuncDefNode node) {   
    108             return (ParameterListNode) node.child(1);
    109         }
    110         public static BlockStmtNode body(FuncDefNode node) {
     104        public static boolean hasParameters(FilterDefNode node) {
     105            return ((node.child(1) instanceof FilterParameterListNode) && (node.child(1).nChildren() > 1));
     106        }
     107        public static FilterParameterListNode parameterListNode(FilterDefNode node) {   
     108            return (FilterParameterListNode) node.child(1);
     109        }
     110        public static BlockStmtNode body(FilterDefNode node) {
    111111            return blockStmtNode(node);
    112112        }
    113         public static BlockStmtNode blockStmtNode(FuncDefNode node) {
    114                 int blockStmtNodeIndex;
    115                
    116                 if(Accessors.hasParameters(node)) {
    117                         blockStmtNodeIndex = 2;
    118                 } else {
    119                         blockStmtNodeIndex = 1;
    120                 }
    121                
    122                 ASTNode child = node.child(blockStmtNodeIndex);
     113        public static BlockStmtNode blockStmtNode(FilterDefNode node) {
     114                ASTNode child = node.child(2);         
    123115                assert child instanceof BlockStmtNode;
    124116        return (BlockStmtNode) child;
     
    422414        } else if(node instanceof FuncCallNode) {
    423415            return funcCallName(nameNode((FuncCallNode)node)); // special case
    424         } else if(node instanceof FuncDefNode) {
    425             return name(nameNode((FuncDefNode)node));
     416        } else if(node instanceof FilterDefNode) {
     417            return name(nameNode((FilterDefNode)node));
    426418        } else if(node instanceof StructDeclNode) {
    427419            return name(nameNode((StructDeclNode)node));
  • proto/s2k/trunk/framework/src/toolchain/b2k/ast/Generators.java

    r3763 r3768  
    109109                        String name,
    110110                        InitDefNode initDefNode,
    111                         FuncDefNode doBlockFuncDefNode,
    112                         FuncDefNode doFinalBlockFuncDefNode,
    113                         FuncDefNode clearFuncDefNode) {
     111                        FilterDefNode doBlockFuncDefNode,
     112                        FilterDefNode doFinalBlockFuncDefNode,
     113                        FilterDefNode clearFuncDefNode) {
    114114               
    115115                        LextantToken token = Generators.makeLextantToken(locator, Lextant.KERNEL);
     
    220220    // Function definitions
    221221    //
    222     public static FuncDefNode makeFuncDefNode(Locator locator, String identifier) {
     222    public static FilterDefNode makeFuncDefNode(Locator locator, String identifier) {
    223223       
    224         LextantToken token = Generators.makeLextantToken(locator, Lextant.FUNCTION);
    225         FuncDefNode funcDef = new FuncDefNode(token);
     224        LextantToken funcToken = Generators.makeLextantToken(locator, Lextant.FUNCTION);
     225        FilterDefNode funcDef = new FilterDefNode(funcToken);
    226226        IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier);
     227        LextantToken parameterListToken = Generators.makeLextantToken(locator, Lextant.LROUND);
     228        FilterParameterListNode parameterListNode = Generators.makeParameterListNode(parameterListToken);
    227229        BlockStmtNode blockStmtNode = Generators.makeBlockStmtNode(locator);
    228230       
    229231        funcDef.appendChild(identifierNode);
     232        funcDef.appendChild(parameterListNode);
    230233        funcDef.appendChild(blockStmtNode);
    231234               
     
    233236    }
    234237   
    235     public static void appendParameter(FuncDefNode funcDefNode, ParameterNode parameterNode) {
    236        
    237         ParameterListNode parameterListNode = null;
     238    public static FilterParameterListNode makeParameterListNode(Token token) { // KH: Token parameter vs. Locator ?
     239        FilterParameterListNode parameterListNode = new FilterParameterListNode(token);
     240        return parameterListNode;
     241    }
     242   
     243    public static ParameterNode makeParameterNode(Locator locator) {
     244        LextantToken parameterListToken = Generators.makeLextantToken(locator, Lextant.LROUND);
     245        ParameterNode parameterNode = new ParameterNode(parameterListToken);
     246        return parameterNode;
     247    }
     248
     249    public static ParameterModeNode makeParameterModeNode(Token token) {
     250        ParameterModeNode parameterModeNode = new ParameterModeNode(token);
     251        return parameterModeNode;
     252    }   
     253   
     254    public static void appendParameter(FilterDefNode funcDefNode, ParameterNode parameterNode) {
     255       
     256        FilterParameterListNode parameterListNode = null;
    238257       
    239258        if(!Accessors.hasParameters(funcDefNode)) {
    240             parameterListNode = new ParameterListNode(parameterNode.getToken()); // KH: refactor to force an parameter list node i.e. not optional ?
     259            parameterListNode = new FilterParameterListNode(parameterNode.getToken());
    241260            funcDefNode.insertAfterChild(Accessors.funcIdentifier(funcDefNode), parameterListNode);
    242261        } else {
  • proto/s2k/trunk/framework/src/toolchain/b2k/ast/Mutators.java

    r3701 r3768  
    55import b2k.ast.ASTNode;
    66import b2k.ast.BlockStmtNode;
    7 import b2k.ast.FuncDefNode;
     7import b2k.ast.FilterDefNode;
    88import b2k.ast.IdentifierNode;
    99import b2k.inputHandler.Locator;
     
    2121        }
    2222       
    23         public static void rename(FuncDefNode node, String newName) {
     23        public static void rename(FilterDefNode node, String newName) {
    2424            IdentifierNode doBlockIdentifier = Generators.makeIdentifierNode(node, newName);
    2525            node.replaceChild(Accessors.funcIdentifier(node), doBlockIdentifier);   
  • proto/s2k/trunk/framework/src/toolchain/b2k/codeGenerator/visitors/Unparser.java

    r3763 r3768  
    177177        }
    178178
    179         public CodeStore visitLeave(FuncDefNode node, List<CodeStore> childResults) {
     179        public CodeStore visitLeave(FilterDefNode node, List<CodeStore> childResults) {
    180180                       
    181181                CodeStore code = new CodeStore();
     
    188188                if(Accessors.hasParameters(node)) {
    189189                        parameters = childResults.get(1).getResultVarName();
    190                         blockStmtCodeStore = childResults.get(2);
    191                 } else {
    192                         blockStmtCodeStore = childResults.get(1);
    193                 }
     190                       
     191                }
     192               
     193                blockStmtCodeStore = childResults.get(2);
    194194               
    195195                code.addFormattedLine("void %s(%s)", funcName, parameters);
     
    208208        }
    209209
    210         public CodeStore visitLeave(ParameterListNode node, List<CodeStore> childResults) {
     210        public CodeStore visitLeave(FilterParameterListNode node, List<CodeStore> childResults) {
    211211                CodeStore code = new CodeStore();               
    212212                Iterator<CodeStore> iter = childResults.iterator();
  • proto/s2k/trunk/framework/src/toolchain/s2k/ast/Accessors.java

    r3763 r3768  
    3131        }
    3232
    33         public static List<FuncDefNode> funcDefs(ProgramNode node) {
     33        public static List<FilterDefNode> funcDefs(ProgramNode node) {
    3434               
    3535                assert node instanceof ProgramNode;
    36                 List<FuncDefNode> funcDefs = new ArrayList<FuncDefNode>();
     36                List<FilterDefNode> funcDefs = new ArrayList<FilterDefNode>();
    3737               
    3838                for(ASTNode child: node.getChildren()) {
    39                         if (child instanceof FuncDefNode) {
    40                                 funcDefs.add((FuncDefNode)child);
     39                        if (child instanceof FilterDefNode) {
     40                                funcDefs.add((FilterDefNode)child);
    4141                        }
    4242                }
     
    5050            List<String> names = new ArrayList<String>();
    5151           
    52             for(FuncDefNode funcDef : funcDefs(node)) {
     52            for(FilterDefNode funcDef : funcDefs(node)) {
    5353                names.add(name(funcDef));
    5454            }
     
    5656        }
    5757       
    58     public static FuncDefNode funcDefForName(ASTNode node, String name) {
    59 
    60         if(node instanceof FuncDefNode) {
     58    public static FilterDefNode funcDefForName(ASTNode node, String name) {
     59
     60        if(node instanceof FilterDefNode) {
    6161            if(name(node).equals(name)) {
    62                 return (FuncDefNode)node;
     62                return (FilterDefNode)node;
    6363            }
    6464        }
    6565
    66         FuncDefNode result = null;
     66        FilterDefNode result = null;
    6767
    6868        for(ASTNode child : node.getChildren()) {
     
    221221//      }
    222222       
    223         public static ASTNode nameNode(FuncDefNode node) {
     223        public static ASTNode nameNode(FilterDefNode node) {
    224224            return node.child(0);
    225225        }
     
    227227//              return typeNode(node).getType();
    228228//      }
    229         public static IdentifierNode funcIdentifier(FuncDefNode node) {
     229        public static IdentifierNode funcIdentifier(FilterDefNode node) {
    230230                return (IdentifierNode) node.child(0);
    231231        }
    232         public static String funcName(FuncDefNode node) {
     232        public static String funcName(FilterDefNode node) {
    233233                return lexeme(funcIdentifier(node));
    234234        }
    235         public static boolean hasParameters(FuncDefNode node) {
    236                 return (node.nChildren()) > 1 && (node.child(1) instanceof ParameterListNode);
    237         }
    238         public static int numParameters(FuncDefNode node) {
     235        public static boolean hasParameters(FilterDefNode node) {
     236                return (node.child(1) instanceof FilterParameterListNode) && (node.child(1).nChildren()) > 1;
     237        }
     238        public static int numParameters(FilterDefNode node) {
    239239            if(hasParameters(node)) {
    240240                return parameterListNode(node).nChildren();
     
    244244            }
    245245        }
    246         public static ParameterListNode parameterListNode(FuncDefNode node) {   
    247                 return (ParameterListNode) node.child(1);
    248         }
    249         public static ParameterNode parameter(FuncDefNode node, int i) {
     246        public static FilterParameterListNode parameterListNode(FilterDefNode node) {   
     247                return (FilterParameterListNode) node.child(1);
     248        }
     249        public static FilterParameterNode parameter(FilterDefNode node, int i) {
    250250                ASTNode list = parameterListNode(node);
    251                 return (ParameterNode)list.child(i);
    252         }
    253         public static BlockStmtNode body(FuncDefNode node) {
     251                return (FilterParameterNode)list.child(i);
     252        }
     253        public static BlockStmtNode body(FilterDefNode node) {
    254254                return blockStmtNode(node);
    255255        }
    256         public static BlockStmtNode blockStmtNode(FuncDefNode node) {
    257                 int blockStmtNodeIndex;
    258                
    259                 if(hasParameters(node)) {
    260                         blockStmtNodeIndex = 3;
    261                 } else {
    262                         blockStmtNodeIndex = 2;
    263                 }
    264                
    265                 ASTNode child = node.child(blockStmtNodeIndex);
     256        public static BlockStmtNode blockStmtNode(FilterDefNode node) {
     257                ASTNode child = node.child(3);
    266258                assert child instanceof BlockStmtNode;
    267259        return (BlockStmtNode) child;
     
    271263        // ParameterNode
    272264        ////////////////////////////////////////////////////////////////////////////
    273         public static ASTNode typeNode(ParameterNode node) {
    274                 return node.child(0);
    275         }
    276        
    277         public static ASTNode nameNode(ParameterNode node) {
     265        public static ASTNode typeNode(FilterParameterNode node) {
     266                return node.child(0);
     267        }
     268       
     269        public static ASTNode nameNode(FilterParameterNode node) {
    278270            return node.child(1);
    279271        }
    280272       
    281         public static Type declarationType(ParameterNode node) {
     273        public static Type declarationType(FilterParameterNode node) {
    282274                ASTNode typeNode = typeNode(node);
    283275                return typeNode.getType();
    284276        }
    285         public static IdentifierNode variableNode(ParameterNode node) {
     277        public static IdentifierNode variableNode(FilterParameterNode node) {
    286278                return (IdentifierNode)(node.child(1));
    287279        }
     
    450442            } else if(node instanceof FuncCallNode) {
    451443                return funcCallName(nameNode((FuncCallNode)node)); // special case
    452             } else if(node instanceof FuncDefNode) {
    453                 return name(nameNode((FuncDefNode)node));
     444            } else if(node instanceof FilterDefNode) {
     445                return name(nameNode((FilterDefNode)node));
    454446            } else if(node instanceof StructDeclNode) {
    455447                return name(nameNode((StructDeclNode)node));
     
    460452            }  else if(node instanceof VarDeclNode) {
    461453                return name(nameNode((VarDeclNode)node));
    462             }  else if(node instanceof ParameterNode) {
    463                 return name(nameNode((ParameterNode)node));
     454            }  else if(node instanceof FilterParameterNode) {
     455                return name(nameNode((FilterParameterNode)node));
    464456            }
    465457            assert false : "Accessors.name(ASTNode node) method not implemented on node class : " + node.getClass();
  • proto/s2k/trunk/framework/src/toolchain/s2k/ast/Generators.java

    r3706 r3768  
    2222        //     but the PLN child has no children if there are no args.  This would eliminate the conditional
    2323        //     in this method, and probably make things easier in other methods, too.
    24         public static void appendParameter(FuncDefNode funcDefNode, ParameterNode parameterNode) {
    25                
    26                 ParameterListNode parameterListNode = null;
    27                
    28                 if(!Accessors.hasParameters(funcDefNode)) {
    29                         parameterListNode = new ParameterListNode(parameterNode.getToken()); // likely needs a fix
    30                         funcDefNode.insertAfterChild(Accessors.funcIdentifier(funcDefNode), parameterListNode);
    31                 } else {
    32                         parameterListNode = Accessors.parameterListNode(funcDefNode);
    33                 }
    34                
     24        public static void appendParameter(FilterDefNode funcDefNode, FilterParameterNode parameterNode) {
     25                FilterParameterListNode parameterListNode = null;
     26                parameterListNode = Accessors.parameterListNode(funcDefNode);
    3527                parameterListNode.appendChild(parameterNode);
    36                
    3728        }
    3829       
  • proto/s2k/trunk/framework/src/toolchain/s2k/semanticAnalyzer/SemanticAnalyzer.java

    r3763 r3768  
    7676                // s t r e a m   f u n c t i o n   d e c l a r a t i o n s                                                     
    7777                //
     78                /*
    7879                @Override
    7980                public void visitEnter(FuncDefNode node) {
    8081                        node.setSymbolTable(new SymbolTable());
    8182                }
     83                */
    8284                /*
    8385                @Override
     
    111113                }
    112114                */
     115                /*
    113116                @Override
    114117                public void visitLeave(ParameterListNode node) {}
     
    123126                        node.setType(declarationType);
    124127                }
    125 
     128                */
    126129               
    127130                //
     
    404407                private boolean isFunctionBeingDefined(IdentifierNode node) {
    405408                        ASTNode parent = node.getParent();
    406                         return ((parent instanceof FuncDefNode) && node == Accessors.funcIdentifier((FuncDefNode) parent));
     409                        return ((parent instanceof FilterDefNode) && node == Accessors.funcIdentifier((FilterDefNode) parent));
    407410                }
    408411                private boolean isVariableBeingDefined(IdentifierNode node) {
  • proto/s2k/trunk/framework/src/toolchain/s2k/transformer/visitors/S2K2B2K/S2K2B2KTransformer.java

    r3763 r3768  
    4646        Context context                                                 = new Context(builtinEncoder, carrySetEncoder, true, false, 0);
    4747        S2K2B2KTranslator S2BXTranslator                                = new S2K2B2KTranslator(propInfoSetMap, context);
    48         ASTNode b2kASTree                                               = s2kASTree.accept(S2BXTranslator);                   
     48        ASTNode b2kASTree                                                   = s2kASTree.accept(S2BXTranslator);                   
    4949
    5050        // S2B final block mode
     
    5454        ASTNode b2kFinalBlockASTree                                     = s2kFinalBlockASTree.accept(finalBlockS2BTranslator);
    5555       
    56         List<s2k.ast.FuncDefNode> funcDefs = toolchain.s2k.ast.Accessors.funcDefs((s2k.ast.ProgramNode) s2kASTree);
    57        
    58         for(s2k.ast.FuncDefNode funcDef : funcDefs) {
     56        List<s2k.ast.FilterDefNode> funcDefs = toolchain.s2k.ast.Accessors.funcDefs((s2k.ast.ProgramNode) s2kASTree);
     57       
     58        for(s2k.ast.FilterDefNode funcDef : funcDefs) {
    5959           
    6060            String kernelName           = toolchain.s2k.ast.Accessors.name(funcDef);
     
    6666            addCarryInitFuncCallNodes(carryInitFuncCalls, initDef);
    6767           
    68             FuncDefNode doBlockFuncDef      = Accessors.funcDefForName(b2kASTree, kernelName);
    69             FuncDefNode doFinalBlockFuncDef = Accessors.funcDefForName(b2kFinalBlockASTree, kernelName);
     68            FilterDefNode doBlockFuncDef      = Accessors.funcDefForName(b2kASTree, kernelName);
     69            FilterDefNode doFinalBlockFuncDef = Accessors.funcDefForName(b2kFinalBlockASTree, kernelName);
    7070           
    7171            Mutators.rename(doBlockFuncDef, DO_BLOCK.b2kName());         
    7272            Mutators.rename(doFinalBlockFuncDef, DO_FINAL_BLOCK.b2kName());
    7373           
    74             FuncDefNode clearFuncDef            = makeClearFuncDefNode(locator, CLEAR.b2kName());
     74            FilterDefNode clearFuncDef          = makeClearFuncDefNode(locator, CLEAR.b2kName());
    7575            addCarryInitFuncCallNodes(carryInitFuncCalls, clearFuncDef);
    7676                       
     
    106106    }
    107107
    108     private static void addCarryInitFuncCallNodes(List<FuncCallNode> carryInitFuncCallNodes, FuncDefNode funcDef) {
     108    private static void addCarryInitFuncCallNodes(List<FuncCallNode> carryInitFuncCallNodes, FilterDefNode funcDef) {
    109109        for(FuncCallNode funcCall : carryInitFuncCallNodes) {
    110110                Accessors.body(funcDef).appendChild(funcCall);
     
    170170    }
    171171   
    172     private static FuncDefNode makeClearFuncDefNode(Locator locator, String funcName) {
    173        
    174        
    175         FuncDefNode funcDef = Generators.makeFuncDefNode(locator, funcName);
    176        
     172    private static FilterDefNode makeClearFuncDefNode(Locator locator, String funcName) {
     173        FilterDefNode funcDef = Generators.makeFuncDefNode(locator, funcName);
    177174        return funcDef;
    178        
    179175    }
    180176   
     
    224220       
    225221        ////////////////////////////////////////////////////////////////////////////////////
    226         // FuncDef
    227         //
    228         public ASTNode visitLeave(s2k.ast.FuncDefNode snode, List<ASTNode> childResults) {
     222        // FilterDef
     223        //
     224        public ASTNode visitLeave(s2k.ast.FilterParameterListNode snode, List<ASTNode> childResults) {
     225                ASTNode replacement = Generators.makeParameterListNode(Generators.makeToken(snode.getToken()));
     226                appendChildResults(replacement, childResults);
     227                return replacement;             
     228        }
     229       
     230        ////////////////////////////////////////////////////////////////////////////////////
     231        // FilterParameterModeNode
     232        public ASTNode visitLeave(s2k.ast.FilterParameterModeNode snode, List<ASTNode> childResults) {
     233                ASTNode replacement = Generators.makeParameterModeNode(Generators.makeToken(snode.getToken()));
     234                return replacement;             
     235        }
     236
     237       
     238        public ASTNode visitLeave(s2k.ast.FilterParameterNode snode, List<ASTNode> childResults) {
     239                ASTNode replacement = Generators.makeParameterNode(Generators.makeToken(snode.getToken()));
     240                appendChildResults(replacement, childResults);
     241                return replacement;
     242        }       
     243       
     244        public ASTNode visitLeave(s2k.ast.FilterDefNode snode, List<ASTNode> childResults) {
    229245           
    230246            ASTNode replacement = defaultVisitLeave(snode, childResults);
     
    233249
    234250            if(needsCarryAdjustment(context, carry1Count) ) { 
    235                 addCarryAdjustment((FuncDefNode) replacement, context, carry1Count);
     251                addCarryAdjustment((FilterDefNode) replacement, context, carry1Count);
    236252            }
    237253                       
    238254            if(context.isFinalBlockMode()) {
    239                 if(!hasEOFMaskParameter((FuncDefNode)replacement)) {
     255                if(!hasEOFMaskParameter((FilterDefNode)replacement)) {
    240256                    b2k.ast.ParameterNode EOFMaskParameter = Generators.makeEofMaskParameter(replacement);
    241                     Generators.appendParameter((FuncDefNode) replacement, EOFMaskParameter);
     257                    Generators.appendParameter((FilterDefNode) replacement, EOFMaskParameter);
    242258                }
    243259            }
     
    250266        }
    251267
    252         private void addCarryAdjustment(FuncDefNode node, Context context, int carry1Count) {
     268        private void addCarryAdjustment(FilterDefNode node, Context context, int carry1Count) {
    253269            FuncCallNode carryAdjustment = Generators.makeCarryAdjustmentCall(node, context, carry1Count);
    254270            ASTNode body = Accessors.body(node);
     
    256272        }       
    257273       
    258         private boolean hasEOFMaskParameter(FuncDefNode node) {
     274        private boolean hasEOFMaskParameter(FilterDefNode node) {
    259275            if(Accessors.hasParameters(node)) {
    260                 ParameterListNode parameterList = Accessors.parameterListNode(node);
     276                FilterParameterListNode parameterList = Accessors.parameterListNode(node);
    261277                ASTNode lastParameter = parameterList.lastChild();
    262278
  • proto/s2k/trunk/framework/src/toolchain/s2k/transformer/visitors/S2K2S2K/CombineScopes.java

    r3708 r3768  
    4848        private Labeller labeller;
    4949       
    50         public void visitEnter(FuncDefNode node) {
     50        public void visitEnter(FilterDefNode node) {
    5151            node.setSymbolTable(new SymbolTable());
    5252            labeller = new Labeller("_v");
     
    119119        public void visitLeave(IdentifierNode node) {
    120120            // KH: logic, if hasMangledName, substitute mangled name for normal name
    121             if(node.getParent() instanceof FuncDefNode) {
    122                 // no action
    123             } else if (node.getParent() instanceof ParameterNode) {
     121            if(node.getParent() instanceof FilterDefNode) {
     122                // no action
     123            } else if (node.getParent() instanceof FilterParameterNode) {
    124124                // no action
    125125            } else if (node.getParent() instanceof StructTypeNode) {
     
    176176       
    177177       
    178         public void visitEnter(FuncDefNode node) {
     178        public void visitEnter(FilterDefNode node) {
    179179            varDecls = new ArrayList<ASTNode>();
    180180            varDeclsForDeletion = new LinkedHashMap<ASTNode, List<ASTNode>>();   
    181181        }
    182182               
    183         public void visitLeave(FuncDefNode node) {
     183        public void visitLeave(FilterDefNode node) {
    184184
    185185            Collections.reverse(varDecls);
  • proto/s2k/trunk/framework/src/toolchain/s2k/transformer/visitors/S2K2S2K/StreamFunctionDefs.java

    r3708 r3768  
    1010import s2k.ast.*;
    1111
    12 public class StreamFunctionDefs extends ArrayList<FuncDefNode> {
     12public class StreamFunctionDefs extends ArrayList<FilterDefNode> {
    1313       
    1414        private static final long serialVersionUID = 8639586378925373084L;
    1515
    16         public static ArrayList<FuncDefNode> forTree(ASTNode ASTTree) {
     16        public static ArrayList<FilterDefNode> forTree(ASTNode ASTTree) {
    1717            Visitor visitor = new Visitor();
    1818                ASTTree.accept(visitor);
     
    2222        private static class Visitor extends VoidVisitor.Default {
    2323               
    24                 private ArrayList<FuncDefNode> list = new ArrayList<FuncDefNode>();
     24                private ArrayList<FilterDefNode> list = new ArrayList<FilterDefNode>();
    2525                               
    26                 public void visitLeave(FuncDefNode node) {
     26                public void visitLeave(FilterDefNode node) {
    2727                        list.add(node);                                 
    2828                }               
  • proto/s2k/trunk/framework/src/toolchain/s2k/transformer/visitors/S2K2S2K/TempifyCarrySetBuiltinCalls.java

    r3708 r3768  
    9595        // visitor callbacks
    9696           
    97             public void visitEnter(FuncDefNode node) {
     97            public void visitEnter(FilterDefNode node) {
    9898                labeller.reset();
    9999               
  • proto/s2k/trunk/framework/src/toolchain/s2k/transformer/visitors/infoSet/PropertyInfoSetMapBuilder.java

    r3708 r3768  
    4141        }
    4242       
    43         public void visitEnter(FuncDefNode node) {
     43        public void visitEnter(FilterDefNode node) {
    4444            carry1Position = 0;
    4545            carryNPosition = 0;
    4646        }
    4747       
    48         public void visitLeave(FuncDefNode node) {
     48        public void visitLeave(FilterDefNode node) {
    4949            PropertyInfoSet propInfoSet = new PropertyInfoSet(carry1Position, carryNPosition, Carry1Count.forTree(node), CarryNCount.forTree(node), Carry1InitialValues.forTree(node)); // add LA, LB
    5050            propInfoSetMap.put(node, propInfoSet);
Note: See TracChangeset for help on using the changeset viewer.