Changeset 3774


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

Updated toolchain for filter definitions.

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

Legend:

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

    r3768 r3774  
    4848        ////////////////////////////////////////////////////////////////////////////
    4949                       
    50         public static FilterDefNode funcDefNode(KernelDefNode node) {
    51                 return (FilterDefNode) node.child(1);
     50        public static FuncDefNode funcDefNode(KernelDefNode node) {
     51                return (FuncDefNode) node.child(1);
    5252        }
    5353       
    5454        public static boolean hasFinalBlockFuncDef(KernelDefNode node) {
    55                 if(node.nChildren() > 3 && (node.child(3) instanceof FilterDefNode)) {
     55                if(node.nChildren() > 3 && (node.child(3) instanceof FuncDefNode)) {
    5656                        return true;
    5757                }
     
    5959        }       
    6060       
    61         public static FilterDefNode finalBlockFuncDefNode(KernelDefNode node) {
     61        public static FuncDefNode finalBlockFuncDefNode(KernelDefNode node) {
    6262                assert hasFinalBlockFuncDef(node);
    63                 return (FilterDefNode) node.child(2);
     63                return (FuncDefNode) node.child(2);
    6464        }
    6565       
     
    6868        }
    6969       
    70     public static FilterDefNode funcDefForName(ASTNode node, String name) {
    71 
    72         if(node instanceof FilterDefNode) {
     70    public static FuncDefNode funcDefForName(ASTNode node, String name) {
     71
     72        if(node instanceof FuncDefNode) {
    7373            if(name(node).equals(name)) {
    74                 return (FilterDefNode)node;
     74                return (FuncDefNode)node;
    7575            }
    7676        }
    7777
    78         FilterDefNode result = null;
     78        FuncDefNode result = null;
    7979
    8080        for(ASTNode child : node.getChildren()) {
     
    9595        // Function Definition
    9696        ////////////////////////////////////////////////////////////////////////////
    97         public static IdentifierNode funcIdentifier(FilterDefNode node) {
     97        public static IdentifierNode funcIdentifier(FuncDefNode node) {
    9898                return (IdentifierNode) node.child(0);
    9999        }
    100100       
    101         public static ASTNode nameNode(FilterDefNode node) {
     101        public static ASTNode nameNode(FuncDefNode node) {
    102102            return node.child(0);
    103103        }
    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) {
     104        public static boolean hasParameters(FuncDefNode node) {
     105            return ((node.child(1) instanceof ParameterListNode) && (node.child(1).nChildren() > 1));
     106        }
     107        public static ParameterListNode parameterListNode(FuncDefNode node) {   
     108            return (ParameterListNode) node.child(1);
     109        }
     110        public static BlockStmtNode body(FuncDefNode node) {
    111111            return blockStmtNode(node);
    112112        }
    113         public static BlockStmtNode blockStmtNode(FilterDefNode node) {
     113        public static BlockStmtNode blockStmtNode(FuncDefNode node) {
    114114                ASTNode child = node.child(2);         
    115115                assert child instanceof BlockStmtNode;
     
    414414        } else if(node instanceof FuncCallNode) {
    415415            return funcCallName(nameNode((FuncCallNode)node)); // special case
    416         } else if(node instanceof FilterDefNode) {
    417             return name(nameNode((FilterDefNode)node));
     416        } else if(node instanceof FuncDefNode) {
     417            return name(nameNode((FuncDefNode)node));
    418418        } else if(node instanceof StructDeclNode) {
    419419            return name(nameNode((StructDeclNode)node));
  • proto/s2k/trunk/framework/src/toolchain/b2k/ast/Generators.java

    r3768 r3774  
    109109                        String name,
    110110                        InitDefNode initDefNode,
    111                         FilterDefNode doBlockFuncDefNode,
    112                         FilterDefNode doFinalBlockFuncDefNode,
    113                         FilterDefNode clearFuncDefNode) {
     111                        FuncDefNode doBlockFuncDefNode,
     112                        FuncDefNode doFinalBlockFuncDefNode,
     113                        FuncDefNode clearFuncDefNode) {
    114114               
    115115                        LextantToken token = Generators.makeLextantToken(locator, Lextant.KERNEL);
     
    220220    // Function definitions
    221221    //
    222     public static FilterDefNode makeFuncDefNode(Locator locator, String identifier) {
     222    public static FuncDefNode makeFuncDefNode(Locator locator, String identifier) {
    223223       
    224224        LextantToken funcToken = Generators.makeLextantToken(locator, Lextant.FUNCTION);
    225         FilterDefNode funcDef = new FilterDefNode(funcToken);
     225        FuncDefNode funcDef = new FuncDefNode(funcToken);
    226226        IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier);
    227227        LextantToken parameterListToken = Generators.makeLextantToken(locator, Lextant.LROUND);
    228         FilterParameterListNode parameterListNode = Generators.makeParameterListNode(parameterListToken);
     228        ParameterListNode parameterListNode = Generators.makeParameterListNode(parameterListToken);
    229229        BlockStmtNode blockStmtNode = Generators.makeBlockStmtNode(locator);
    230230       
     
    236236    }
    237237   
    238     public static FilterParameterListNode makeParameterListNode(Token token) { // KH: Token parameter vs. Locator ?
    239         FilterParameterListNode parameterListNode = new FilterParameterListNode(token);
     238    public static ParameterListNode makeParameterListNode(Token token) { // KH: Token parameter vs. Locator ?
     239        ParameterListNode parameterListNode = new ParameterListNode(token);
    240240        return parameterListNode;
    241241    }
     
    252252    }   
    253253   
    254     public static void appendParameter(FilterDefNode funcDefNode, ParameterNode parameterNode) {
    255        
    256         FilterParameterListNode parameterListNode = null;
     254    public static void appendParameter(FuncDefNode funcDefNode, ParameterNode parameterNode) {
     255       
     256        ParameterListNode parameterListNode = null;
    257257       
    258258        if(!Accessors.hasParameters(funcDefNode)) {
    259             parameterListNode = new FilterParameterListNode(parameterNode.getToken()); 
     259            parameterListNode = new ParameterListNode(parameterNode.getToken()); 
    260260            funcDefNode.insertAfterChild(Accessors.funcIdentifier(funcDefNode), parameterListNode);
    261261        } else {
  • proto/s2k/trunk/framework/src/toolchain/b2k/ast/Mutators.java

    r3768 r3774  
    55import b2k.ast.ASTNode;
    66import b2k.ast.BlockStmtNode;
    7 import b2k.ast.FilterDefNode;
     7import b2k.ast.FuncDefNode;
    88import b2k.ast.IdentifierNode;
    99import b2k.inputHandler.Locator;
     
    2121        }
    2222       
    23         public static void rename(FilterDefNode node, String newName) {
     23        public static void rename(FuncDefNode 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

    r3768 r3774  
    177177        }
    178178
    179         public CodeStore visitLeave(FilterDefNode node, List<CodeStore> childResults) {
     179        public CodeStore visitLeave(FuncDefNode node, List<CodeStore> childResults) {
    180180                       
    181181                CodeStore code = new CodeStore();
     
    208208        }
    209209
    210         public CodeStore visitLeave(FilterParameterListNode node, List<CodeStore> childResults) {
     210        public CodeStore visitLeave(ParameterListNode 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

    r3768 r3774  
    3131        }
    3232
    33         public static List<FilterDefNode> funcDefs(ProgramNode node) {
     33        public static List<FuncDefNode> funcDefs(ProgramNode node) {
    3434               
    3535                assert node instanceof ProgramNode;
    36                 List<FilterDefNode> funcDefs = new ArrayList<FilterDefNode>();
     36                List<FuncDefNode> funcDefs = new ArrayList<FuncDefNode>();
    3737               
    3838                for(ASTNode child: node.getChildren()) {
    39                         if (child instanceof FilterDefNode) {
    40                                 funcDefs.add((FilterDefNode)child);
     39                        if (child instanceof FuncDefNode) {
     40                                funcDefs.add((FuncDefNode)child);
    4141                        }
    4242                }
     
    5050            List<String> names = new ArrayList<String>();
    5151           
    52             for(FilterDefNode funcDef : funcDefs(node)) {
     52            for(FuncDefNode funcDef : funcDefs(node)) {
    5353                names.add(name(funcDef));
    5454            }
     
    5656        }
    5757       
    58     public static FilterDefNode funcDefForName(ASTNode node, String name) {
    59 
    60         if(node instanceof FilterDefNode) {
     58    public static FuncDefNode funcDefForName(ASTNode node, String name) {
     59
     60        if(node instanceof FuncDefNode) {
    6161            if(name(node).equals(name)) {
    62                 return (FilterDefNode)node;
     62                return (FuncDefNode)node;
    6363            }
    6464        }
    6565
    66         FilterDefNode result = null;
     66        FuncDefNode result = null;
    6767
    6868        for(ASTNode child : node.getChildren()) {
     
    221221//      }
    222222       
    223         public static ASTNode nameNode(FilterDefNode node) {
     223        public static ASTNode nameNode(FuncDefNode node) {
    224224            return node.child(0);
    225225        }
     
    227227//              return typeNode(node).getType();
    228228//      }
    229         public static IdentifierNode funcIdentifier(FilterDefNode node) {
     229        public static IdentifierNode funcIdentifier(FuncDefNode node) {
    230230                return (IdentifierNode) node.child(0);
    231231        }
    232         public static String funcName(FilterDefNode node) {
     232        public static String funcName(FuncDefNode node) {
    233233                return lexeme(funcIdentifier(node));
    234234        }
    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) {
     235        public static boolean hasParameters(FuncDefNode node) {
     236                return (node.child(1) instanceof ParameterListNode) && (node.child(1).nChildren()) > 1;
     237        }
     238        public static int numParameters(FuncDefNode node) {
    239239            if(hasParameters(node)) {
    240240                return parameterListNode(node).nChildren();
     
    244244            }
    245245        }
    246         public static FilterParameterListNode parameterListNode(FilterDefNode node) {   
    247                 return (FilterParameterListNode) node.child(1);
    248         }
    249         public static FilterParameterNode parameter(FilterDefNode node, int i) {
     246        public static ParameterListNode parameterListNode(FuncDefNode node) {   
     247                return (ParameterListNode) node.child(1);
     248        }
     249        public static FilterParameterNode parameter(FuncDefNode node, int i) {
    250250                ASTNode list = parameterListNode(node);
    251251                return (FilterParameterNode)list.child(i);
    252252        }
    253         public static BlockStmtNode body(FilterDefNode node) {
     253        public static BlockStmtNode body(FuncDefNode node) {
    254254                return blockStmtNode(node);
    255255        }
    256         public static BlockStmtNode blockStmtNode(FilterDefNode node) {
     256        public static BlockStmtNode blockStmtNode(FuncDefNode node) {
    257257                ASTNode child = node.child(3);
    258258                assert child instanceof BlockStmtNode;
     
    442442            } else if(node instanceof FuncCallNode) {
    443443                return funcCallName(nameNode((FuncCallNode)node)); // special case
    444             } else if(node instanceof FilterDefNode) {
    445                 return name(nameNode((FilterDefNode)node));
     444            } else if(node instanceof FuncDefNode) {
     445                return name(nameNode((FuncDefNode)node));
    446446            } else if(node instanceof StructDeclNode) {
    447447                return name(nameNode((StructDeclNode)node));
  • proto/s2k/trunk/framework/src/toolchain/s2k/ast/Generators.java

    r3768 r3774  
    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(FilterDefNode funcDefNode, FilterParameterNode parameterNode) {
    25                 FilterParameterListNode parameterListNode = null;
     24        public static void appendParameter(FuncDefNode funcDefNode, FilterParameterNode parameterNode) {
     25                ParameterListNode parameterListNode = null;
    2626                parameterListNode = Accessors.parameterListNode(funcDefNode);
    2727                parameterListNode.appendChild(parameterNode);
  • proto/s2k/trunk/framework/src/toolchain/s2k/semanticAnalyzer/SemanticAnalyzer.java

    r3768 r3774  
    407407                private boolean isFunctionBeingDefined(IdentifierNode node) {
    408408                        ASTNode parent = node.getParent();
    409                         return ((parent instanceof FilterDefNode) && node == Accessors.funcIdentifier((FilterDefNode) parent));
     409                        return ((parent instanceof FuncDefNode) && node == Accessors.funcIdentifier((FuncDefNode) parent));
    410410                }
    411411                private boolean isVariableBeingDefined(IdentifierNode node) {
  • proto/s2k/trunk/framework/src/toolchain/s2k/transformer/visitors/S2K2B2K/S2K2B2KTransformer.java

    r3768 r3774  
    5454        ASTNode b2kFinalBlockASTree                                     = s2kFinalBlockASTree.accept(finalBlockS2BTranslator);
    5555       
    56         List<s2k.ast.FilterDefNode> funcDefs = toolchain.s2k.ast.Accessors.funcDefs((s2k.ast.ProgramNode) s2kASTree);
    57        
    58         for(s2k.ast.FilterDefNode funcDef : funcDefs) {
     56        List<s2k.ast.FuncDefNode> funcDefs = toolchain.s2k.ast.Accessors.funcDefs((s2k.ast.ProgramNode) s2kASTree);
     57       
     58        for(s2k.ast.FuncDefNode funcDef : funcDefs) {
    5959           
    6060            String kernelName           = toolchain.s2k.ast.Accessors.name(funcDef);
     
    6666            addCarryInitFuncCallNodes(carryInitFuncCalls, initDef);
    6767           
    68             FilterDefNode doBlockFuncDef      = Accessors.funcDefForName(b2kASTree, kernelName);
    69             FilterDefNode doFinalBlockFuncDef = Accessors.funcDefForName(b2kFinalBlockASTree, kernelName);
     68            FuncDefNode doBlockFuncDef      = Accessors.funcDefForName(b2kASTree, kernelName);
     69            FuncDefNode doFinalBlockFuncDef = Accessors.funcDefForName(b2kFinalBlockASTree, kernelName);
    7070           
    7171            Mutators.rename(doBlockFuncDef, DO_BLOCK.b2kName());         
    7272            Mutators.rename(doFinalBlockFuncDef, DO_FINAL_BLOCK.b2kName());
    7373           
    74             FilterDefNode clearFuncDef          = makeClearFuncDefNode(locator, CLEAR.b2kName());
     74            FuncDefNode clearFuncDef            = makeClearFuncDefNode(locator, CLEAR.b2kName());
    7575            addCarryInitFuncCallNodes(carryInitFuncCalls, clearFuncDef);
    7676                       
     
    106106    }
    107107
    108     private static void addCarryInitFuncCallNodes(List<FuncCallNode> carryInitFuncCallNodes, FilterDefNode funcDef) {
     108    private static void addCarryInitFuncCallNodes(List<FuncCallNode> carryInitFuncCallNodes, FuncDefNode funcDef) {
    109109        for(FuncCallNode funcCall : carryInitFuncCallNodes) {
    110110                Accessors.body(funcDef).appendChild(funcCall);
     
    170170    }
    171171   
    172     private static FilterDefNode makeClearFuncDefNode(Locator locator, String funcName) {
    173         FilterDefNode funcDef = Generators.makeFuncDefNode(locator, funcName);
     172    private static FuncDefNode makeClearFuncDefNode(Locator locator, String funcName) {
     173        FuncDefNode funcDef = Generators.makeFuncDefNode(locator, funcName);
    174174        return funcDef;
    175175    }
     
    222222        // FilterDef
    223223        //
    224         public ASTNode visitLeave(s2k.ast.FilterParameterListNode snode, List<ASTNode> childResults) {
     224        public ASTNode visitLeave(s2k.ast.ParameterListNode snode, List<ASTNode> childResults) {
    225225                ASTNode replacement = Generators.makeParameterListNode(Generators.makeToken(snode.getToken()));
    226226                appendChildResults(replacement, childResults);
     
    242242        }       
    243243       
    244         public ASTNode visitLeave(s2k.ast.FilterDefNode snode, List<ASTNode> childResults) {
     244        public ASTNode visitLeave(s2k.ast.FuncDefNode snode, List<ASTNode> childResults) {
    245245           
    246246            ASTNode replacement = defaultVisitLeave(snode, childResults);
     
    249249
    250250            if(needsCarryAdjustment(context, carry1Count) ) { 
    251                 addCarryAdjustment((FilterDefNode) replacement, context, carry1Count);
     251                addCarryAdjustment((FuncDefNode) replacement, context, carry1Count);
    252252            }
    253253                       
    254254            if(context.isFinalBlockMode()) {
    255                 if(!hasEOFMaskParameter((FilterDefNode)replacement)) {
     255                if(!hasEOFMaskParameter((FuncDefNode)replacement)) {
    256256                    b2k.ast.ParameterNode EOFMaskParameter = Generators.makeEofMaskParameter(replacement);
    257                     Generators.appendParameter((FilterDefNode) replacement, EOFMaskParameter);
     257                    Generators.appendParameter((FuncDefNode) replacement, EOFMaskParameter);
    258258                }
    259259            }
     
    266266        }
    267267
    268         private void addCarryAdjustment(FilterDefNode node, Context context, int carry1Count) {
     268        private void addCarryAdjustment(FuncDefNode node, Context context, int carry1Count) {
    269269            FuncCallNode carryAdjustment = Generators.makeCarryAdjustmentCall(node, context, carry1Count);
    270270            ASTNode body = Accessors.body(node);
     
    272272        }       
    273273       
    274         private boolean hasEOFMaskParameter(FilterDefNode node) {
     274        private boolean hasEOFMaskParameter(FuncDefNode node) {
    275275            if(Accessors.hasParameters(node)) {
    276                 FilterParameterListNode parameterList = Accessors.parameterListNode(node);
     276                ParameterListNode parameterList = Accessors.parameterListNode(node);
    277277                ASTNode lastParameter = parameterList.lastChild();
    278278
  • proto/s2k/trunk/framework/src/toolchain/s2k/transformer/visitors/S2K2S2K/CombineScopes.java

    r3768 r3774  
    4848        private Labeller labeller;
    4949       
    50         public void visitEnter(FilterDefNode node) {
     50        public void visitEnter(FuncDefNode 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 FilterDefNode) {
     121            if(node.getParent() instanceof FuncDefNode) {
    122122                // no action
    123123            } else if (node.getParent() instanceof FilterParameterNode) {
     
    176176       
    177177       
    178         public void visitEnter(FilterDefNode node) {
     178        public void visitEnter(FuncDefNode node) {
    179179            varDecls = new ArrayList<ASTNode>();
    180180            varDeclsForDeletion = new LinkedHashMap<ASTNode, List<ASTNode>>();   
    181181        }
    182182               
    183         public void visitLeave(FilterDefNode node) {
     183        public void visitLeave(FuncDefNode node) {
    184184
    185185            Collections.reverse(varDecls);
  • proto/s2k/trunk/framework/src/toolchain/s2k/transformer/visitors/S2K2S2K/StreamFunctionDefs.java

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

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

    r3768 r3774  
    4141        }
    4242       
    43         public void visitEnter(FilterDefNode node) {
     43        public void visitEnter(FuncDefNode node) {
    4444            carry1Position = 0;
    4545            carryNPosition = 0;
    4646        }
    4747       
    48         public void visitLeave(FilterDefNode node) {
     48        public void visitLeave(FuncDefNode 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.