Changeset 3778


Ignore:
Timestamp:
Apr 1, 2014, 6:14:20 PM (3 years ago)
Author:
ksherdy
Message:

Minors updates to b2k grammar.

Location:
proto/s2k/trunk/framework
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • proto/s2k/trunk/framework/input/grammar/scatter/b2k.scatter

    r3769 r3778  
    11//
    2 // Tom Shermer, Ken Herdy
     2// b2k - A very high-level IR for the expression of block-by-block parallel bit stream processing.
    33//
    4 // b2k - Very high-level IR for the expression of block-by-block parallel bit stream processing.
     4// 02-12-2012      Original definition.
     5// 29-03-2013      Added IDISA function call.
     6// 06-04-2013      Updated to Scatter with types.
    57//
    6 // Modified:    02-12-2012      Original definition.
    7 //              29-03-2013      Added IDISA function call.
    8 //              06-04-2013      Updated to Scatter with types.
    98//
     9//
     10// Tom Shermer <shermer at sfu dot ca>
     11// Ken Herdy <ksherdy at sfu dot ca>
     12//
     13
    1014
    1115types {
     
    4246        BOOL,
    4347        BITFIELD    "BitField",
    44         BITBLOCK    "BitBlock", // alias for architecture dependent SIMD type
     48        BITBLOCK    "BitBlock",
    4549        //CODEBLOCK,
    4650        IF,
     
    7983grammar {
    8084   
    81     program     -> (structDecl | kernelDef) * ;
     85    program     -> (structDef | kernelDef) * ;
    8286   
    8387    //
    84     // s t r u c t   d e c l a r a t i o n s 
     88    // s t r u c t   d e f i n i t i o n 
    8589    //
    86     structDecl          ->  STRUCT structName structDeclBody TERMINATOR? ;
    87     structDeclBody      ->  LCURLY (structMember TERMINATOR)+ RCURLY ;
     90    structDef           ->  STRUCT structName structDefBody TERMINATOR? ;
     91    structDefBody       ->  LCURLY (structMember TERMINATOR)+ RCURLY ;
    8892    structMember        ->  structMemberType structMemberName ;
    89     structMemberType    #-> structType | bitBlockType ;
     93    structMemberType    #-> bitBlockType ;
    9094    structMemberName    #-> identifier ;
    9195
    9296    //
    93     // k e r n e l   d e c l a r a t i o n s
     97    // k e r n e l   d e f i n i t i o n
    9498    //
    95     kernelDef           ->  KERNEL kernelName LCURLY initDef funcDef (funcDef)* carryDeclare TERMINATOR RCURLY TERMINATOR? ; 
     99    kernelDef           ->  KERNEL kernelName LCURLY kernelInitDef (kernelFuncDef)+ carryDeclare TERMINATOR RCURLY TERMINATOR? ; 
    96100    kernelName          #-> identifier ;
    97101
     
    99103    // k e r n e l   p r o p e r t i e s 
    100104    //
    101     initDef             #-> INIT LCURLY kernelProperty* RCURLY TERMINATOR? ;
     105    kernelInitDef       #-> INIT LCURLY kernelProperty* RCURLY TERMINATOR? ;
    102106    kernelProperty      ->  propertyName ASSIGN propertyValue TERMINATOR ;
    103107    propertyName        #-> identifier ;
     
    105109
    106110    //
    107     // k e r n e l   f u n c t i o n s
     111    // k e r n e l   f u n c t i o n   d e f i n i t i o n
    108112    //
    109     funcDef             ->  FUNCTION funcName LROUND parameterList RROUND basicBlockStmt TERMINATOR? ;
    110     parameterList       ->  (parameter (COMMA parameter)* )?;
    111     funcName            #-> identifier ;
    112     parameter           ->  (parameterMode)? type parameterName ;
    113     parameterMode               ->  (IN | OUT | INOUT) ;
    114     parameterName      #-> identifier ;
    115     basicBlockStmt      #-> blockStmt ;
     113    kernelFuncDef       ->  FUNCTION kernelFuncName LROUND kernelParameterList RROUND kernelFuncBody TERMINATOR? ;
     114    kernelParameterList ->  (kernelParameter (COMMA kernelParameter)* )?;
     115    kernelFuncName      #-> identifier ;
     116    kernelParameter     ->  (kernelParameterMode)? type kernelParameterName ;
     117    kernelParameterMode ->  (IN | OUT | INOUT) ;
     118    kernelParameterName #-> identifier ;
     119    kernelFuncBody      #-> blockStmt ;
    116120    carryDeclare                #-> expr; // KH: temp hack to append the CarryDeclare() macro
    117121
     
    143147    // e x p r e s s i o n s
    144148    //   
    145     expr            #-> LROUND expr RROUND
    146                     | constant
    147                     | compoundIdentifier ((funcCallRest _promote_) | (idisaFuncCallRest _promote_)) ? ;
     149    expr                #-> LROUND expr RROUND
     150                         | constant
     151                         | compoundIdentifier ((funcCallRest _promote_) | (idisaFuncCallRest _promote_)) ? ;
    148152
    149153    constant            #->     stringConstant | integerConstant ;
  • proto/s2k/trunk/framework/src/toolchain/b2k/ast/Accessors.java

    r3777 r3778  
    4848        ////////////////////////////////////////////////////////////////////////////
    4949                       
    50         public static FuncDefNode funcDefNode(KernelDefNode node) {
    51                 return (FuncDefNode) node.child(1);
     50        public static KernelFuncDefNode kernelFuncDefNode(KernelDefNode node) {
     51                return (KernelFuncDefNode) 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 KernelFuncDefNode)) {
    5656                        return true;
    5757                }
     
    5959        }       
    6060       
    61         public static FuncDefNode finalBlockFuncDefNode(KernelDefNode node) {
     61        public static KernelFuncDefNode finalBlockKernelFuncDefNode(KernelDefNode node) {
    6262                assert hasFinalBlockFuncDef(node);
    63                 return (FuncDefNode) node.child(2);
     63                return (KernelFuncDefNode) 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 KernelFuncDefNode funcDefForName(ASTNode node, String name) {
     71
     72        if(node instanceof KernelFuncDefNode) {
    7373            if(name(node).equals(name)) {
    74                 return (FuncDefNode)node;
     74                return (KernelFuncDefNode)node;
    7575            }
    7676        }
    7777
    78         FuncDefNode result = null;
     78        KernelFuncDefNode 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(KernelFuncDefNode node) {
    9898                return (IdentifierNode) node.child(0);
    9999        }
    100100       
    101         public static ASTNode nameNode(FuncDefNode node) {
     101        public static ASTNode nameNode(KernelFuncDefNode node) {
    102102            return node.child(0);
    103103        }
    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) {
     104        public static boolean hasParameters(KernelFuncDefNode node) {
     105            return ((node.child(1) instanceof KernelParameterListNode) && (node.child(1).nChildren() > 1));
     106        }
     107        public static KernelParameterListNode parameterListNode(KernelFuncDefNode node) {   
     108            return (KernelParameterListNode) node.child(1);
     109        }
     110        public static BlockStmtNode body(KernelFuncDefNode node) {
    111111            return blockStmtNode(node);
    112112        }
    113         public static BlockStmtNode blockStmtNode(FuncDefNode node) {
     113        public static BlockStmtNode blockStmtNode(KernelFuncDefNode node) {
    114114                ASTNode child = node.child(2);         
    115115                assert child instanceof BlockStmtNode;
     
    298298        // ParameterNode
    299299        ////////////////////////////////////////////////////////////////////////////
    300         public static ASTNode typeNode(ParameterNode node) {
     300        public static ASTNode typeNode(KernelParameterNode node) {
    301301            return node.child(0);
    302302        }
    303303
    304         public static ASTNode nameNode(ParameterNode node) {
     304        public static ASTNode nameNode(KernelParameterNode node) {
    305305            return node.child(1);
    306306        }
     
    414414        } else if(node instanceof FuncCallNode) {
    415415            return funcCallName(nameNode((FuncCallNode)node)); // special case
    416         } else if(node instanceof FuncDefNode) {
    417             return name(nameNode((FuncDefNode)node));
     416        } else if(node instanceof KernelFuncDefNode) {
     417            return name(nameNode((KernelFuncDefNode)node));
    418418        } else if(node instanceof StructDefNode) {
    419419            return name(nameNode((StructDefNode)node));
     
    424424        } else if(node instanceof KernelDefNode) {
    425425            return name(nameNode((KernelDefNode)node));
    426         } else if(node instanceof ParameterNode) {
    427             return name(nameNode((ParameterNode)node));
     426        } else if(node instanceof KernelParameterNode) {
     427            return name(nameNode((KernelParameterNode)node));
    428428        }
    429429        assert false : "Accessors.name(ASTNode node) method not implemented on node class : " + node.getClass();
  • proto/s2k/trunk/framework/src/toolchain/b2k/ast/Generators.java

    r3775 r3778  
    108108        public static KernelDefNode makeKernelDef(Locator locator,
    109109                        String name,
    110                         InitDefNode initDefNode,
    111                         FuncDefNode doBlockFuncDefNode,
    112                         FuncDefNode doFinalBlockFuncDefNode,
    113                         FuncDefNode clearFuncDefNode) {
     110                        KernelInitDefNode kernelInitDefNode,
     111                        KernelFuncDefNode doBlockKernelFuncDefNode,
     112                        KernelFuncDefNode doFinalBlockKernelFuncDefNode,
     113                        KernelFuncDefNode clearKernelFuncDefNode) {
    114114               
    115115                        LextantToken token = Generators.makeLextantToken(locator, Lextant.KERNEL);
     
    118118                       
    119119                        kernelDefNode.appendChild(identifierNode);
    120                         kernelDefNode.appendChild(initDefNode);
    121                         kernelDefNode.appendChild(doBlockFuncDefNode.deepCopy());
    122                         kernelDefNode.appendChild(doFinalBlockFuncDefNode.deepCopy());
    123                         kernelDefNode.appendChild(clearFuncDefNode.deepCopy());
     120                        kernelDefNode.appendChild(kernelInitDefNode);
     121                        kernelDefNode.appendChild(doBlockKernelFuncDefNode.deepCopy());
     122                        kernelDefNode.appendChild(doFinalBlockKernelFuncDefNode.deepCopy());
     123                        kernelDefNode.appendChild(clearKernelFuncDefNode.deepCopy());
    124124                       
    125125                        return kernelDefNode;
     
    130130        }       
    131131
    132     public static InitDefNode makeInitDefNode (Locator locator) {
    133         InitDefNode stateDef = new InitDefNode(Generators.makeLextantToken(locator, Lextant.LCURLY));
    134         return stateDef;
    135     }
    136        
    137         public static InitDefNode makeInitDefNode (Locator locator, KernelPropertyNode ...stateParameters) {
    138                 InitDefNode stateDef = new InitDefNode(Generators.makeLextantToken(locator, Lextant.LCURLY));
     132    public static KernelInitDefNode makeInitDefNode (Locator locator) {
     133        KernelInitDefNode kernelnitDef = new KernelInitDefNode(Generators.makeLextantToken(locator, Lextant.LCURLY));
     134        return kernelnitDef;
     135    }
     136       
     137        public static KernelInitDefNode makeInitDefNode (Locator locator, KernelPropertyNode ...stateParameters) {
     138                KernelInitDefNode kernelnitDef = new KernelInitDefNode(Generators.makeLextantToken(locator, Lextant.LCURLY));
    139139                for(KernelPropertyNode stateParameter : stateParameters) {
    140                     stateDef.appendChild(stateParameter);
     140                    kernelnitDef.appendChild(stateParameter);
    141141                }
    142                 return stateDef;
     142                return kernelnitDef;
    143143        }
    144144
     
    221221    //
    222222   
    223     public static FuncDefNode makeFuncDefNode(Locator locator, String identifier) {
     223    public static KernelFuncDefNode makeKernelFuncDefNode(Locator locator, String identifier) {
    224224       
    225225        LextantToken funcToken = Generators.makeLextantToken(locator, Lextant.FUNCTION);
    226         FuncDefNode funcDef = new FuncDefNode(funcToken);
     226        KernelFuncDefNode funcDef = new KernelFuncDefNode(funcToken);
    227227        IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier);
    228228        LextantToken parameterListToken = Generators.makeLextantToken(locator, Lextant.LROUND);
    229         ParameterListNode parameterListNode = Generators.makeParameterListNode(parameterListToken);
     229        KernelParameterListNode parameterListNode = Generators.makeKernelParameterListNode(parameterListToken);
    230230        BlockStmtNode blockStmtNode = Generators.makeBlockStmtNode(locator);
    231231       
     
    237237    }
    238238   
    239     public static ParameterListNode makeParameterListNode(Token token) { // KH: Token parameter vs. Locator ?
    240         ParameterListNode parameterListNode = new ParameterListNode(token);
     239    public static KernelParameterListNode makeKernelParameterListNode(Token token) { // KH: Token parameter vs. Locator ?
     240        KernelParameterListNode parameterListNode = new KernelParameterListNode(token);
    241241        return parameterListNode;
    242242    }
    243243   
    244     public static ParameterNode makeParameterNode(Locator locator) {
     244    public static KernelParameterNode makeKernelParameterNode(Locator locator) {
    245245        LextantToken parameterListToken = Generators.makeLextantToken(locator, Lextant.LROUND);
    246         ParameterNode parameterNode = new ParameterNode(parameterListToken);
     246        KernelParameterNode parameterNode = new KernelParameterNode(parameterListToken);
    247247        return parameterNode;
    248248    }
    249249
    250     public static ParameterModeNode makeParameterModeNode(Token token) {
    251         ParameterModeNode parameterModeNode = new ParameterModeNode(token);
     250    public static KernelParameterModeNode makeKernelParameterModeNode(Token token) {
     251        KernelParameterModeNode parameterModeNode = new KernelParameterModeNode(token);
    252252        return parameterModeNode;
    253253    }   
    254254   
    255     public static void appendParameter(FuncDefNode funcDefNode, ParameterNode parameterNode) {
    256        
    257         ParameterListNode parameterListNode = null;
    258        
    259         if(!Accessors.hasParameters(funcDefNode)) {
    260             parameterListNode = new ParameterListNode(parameterNode.getToken()); 
    261             funcDefNode.insertAfterChild(Accessors.funcIdentifier(funcDefNode), parameterListNode);
     255    public static void appendParameter(KernelFuncDefNode kernelFuncDefNode, KernelParameterNode parameterNode) {
     256       
     257        KernelParameterListNode parameterListNode = null;
     258       
     259        if(!Accessors.hasParameters(kernelFuncDefNode)) {
     260            parameterListNode = new KernelParameterListNode(parameterNode.getToken()); 
     261            kernelFuncDefNode.insertAfterChild(Accessors.funcIdentifier(kernelFuncDefNode), parameterListNode);
    262262        } else {
    263             parameterListNode = Accessors.parameterListNode(funcDefNode);
     263            parameterListNode = Accessors.parameterListNode(kernelFuncDefNode);
    264264        }
    265265       
     
    450450    }
    451451   
    452     public static ParameterNode makeEofMaskParameter(Locator locator) {
     452    public static KernelParameterNode makeEofMaskParameter(Locator locator) {
    453453
    454454        Token parameterNodeToken = Generators.makeLextantToken(locator, b2k.lexicalAnalyzer.Lextant.BITBLOCK);
    455         ParameterNode parameterNode = new ParameterNode(parameterNodeToken);
     455        KernelParameterNode parameterNode = new KernelParameterNode(parameterNodeToken);
    456456
    457457        Token bitBlockTypeToken = Generators.makeLextantToken(locator, b2k.lexicalAnalyzer.Lextant.BITBLOCK);
  • proto/s2k/trunk/framework/src/toolchain/b2k/ast/Mutators.java

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

    r3777 r3778  
    152152        ////////////////////////////////////////////////////////////////////////////
    153153       
    154         public CodeStore visitLeave(InitDefNode node, List<CodeStore> childResults) {
     154        public CodeStore visitLeave(KernelInitDefNode node, List<CodeStore> childResults) {
    155155                CodeStore code = new CodeStore();
    156156       
     
    177177        }
    178178
    179         public CodeStore visitLeave(FuncDefNode node, List<CodeStore> childResults) {
     179        public CodeStore visitLeave(KernelFuncDefNode node, List<CodeStore> childResults) {
    180180                       
    181181                CodeStore code = new CodeStore();
     
    208208        }
    209209
    210         public CodeStore visitLeave(ParameterListNode node, List<CodeStore> childResults) {
     210        public CodeStore visitLeave(KernelParameterListNode node, List<CodeStore> childResults) {
    211211                CodeStore code = new CodeStore();               
    212212                Iterator<CodeStore> iter = childResults.iterator();
     
    216216       
    217217        // Parameter
    218         public CodeStore visitLeave(ParameterNode node, List<CodeStore> childResults) { 
     218        public CodeStore visitLeave(KernelParameterNode node, List<CodeStore> childResults) { 
    219219                CodeStore code = new CodeStore();
    220220               
  • proto/s2k/trunk/framework/src/toolchain/s2k/transformer/visitors/S2K2B2K/S2K2B2KTransformer.java

    r3775 r3778  
    6363           
    6464            List<FuncCallNode> carryInitFuncCalls       = makeCarryInitFuncCallNodes(locator, context, propInfoSet);
    65             InitDefNode initDef                                 = makeInitDefNode(locator, propInfoSet);
     65            KernelInitDefNode initDef                           = makeKernelInitDefNode(locator, propInfoSet);
    6666            addCarryInitFuncCallNodes(carryInitFuncCalls, initDef);
    6767           
    68             FuncDefNode doBlockFuncDef      = Accessors.funcDefForName(b2kASTree, kernelName);
    69             FuncDefNode doFinalBlockFuncDef = Accessors.funcDefForName(b2kFinalBlockASTree, kernelName);
    70            
    71             Mutators.rename(doBlockFuncDef, DO_BLOCK.b2kName());         
    72             Mutators.rename(doFinalBlockFuncDef, DO_FINAL_BLOCK.b2kName());
    73            
    74             FuncDefNode clearFuncDef            = makeClearFuncDefNode(locator, CLEAR.b2kName());
    75             addCarryInitFuncCallNodes(carryInitFuncCalls, clearFuncDef);
     68            KernelFuncDefNode doBlockKernelFuncDef      = Accessors.funcDefForName(b2kASTree, kernelName);
     69            KernelFuncDefNode doFinalBlockKernelFuncDef = Accessors.funcDefForName(b2kFinalBlockASTree, kernelName);
     70           
     71            Mutators.rename(doBlockKernelFuncDef, DO_BLOCK.b2kName());         
     72            Mutators.rename(doFinalBlockKernelFuncDef, DO_FINAL_BLOCK.b2kName());
     73           
     74            KernelFuncDefNode clearKernelFuncDef                = makeClearKernelFuncDefNode(locator, CLEAR.b2kName());
     75            addCarryInitFuncCallNodes(carryInitFuncCalls, clearKernelFuncDef);
    7676                       
    7777            KernelDefNode kernelDef             = Generators.makeKernelDef(locator,
    7878                                                                            kernelName,
    7979                                                                            initDef,
    80                                                                             doBlockFuncDef,
    81                                                                             doFinalBlockFuncDef,
    82                                                                             clearFuncDef);
     80                                                                            doBlockKernelFuncDef,
     81                                                                            doFinalBlockKernelFuncDef,
     82                                                                            clearKernelFuncDef);
    8383           
    8484            addCarryDeclareFuncCall(locator, context, propInfoSet, kernelDef);
    85             doBlockFuncDef.updateSelf(kernelDef);
     85            doBlockKernelFuncDef.updateSelf(kernelDef);
    8686        }
    8787
     
    106106    }
    107107
    108     private static void addCarryInitFuncCallNodes(List<FuncCallNode> carryInitFuncCallNodes, FuncDefNode funcDef) {
     108    private static void addCarryInitFuncCallNodes(List<FuncCallNode> carryInitFuncCallNodes, KernelFuncDefNode funcDef) {
    109109        for(FuncCallNode funcCall : carryInitFuncCallNodes) {
    110110                Accessors.body(funcDef).appendChild(funcCall);
     
    112112    }
    113113   
    114     private static void addCarryInitFuncCallNodes(List<FuncCallNode> carryInitFuncCallNodes, InitDefNode kernelDef) {
     114    private static void addCarryInitFuncCallNodes(List<FuncCallNode> carryInitFuncCallNodes, KernelInitDefNode kernelDef) {
    115115        for(FuncCallNode funcCall : carryInitFuncCallNodes) {
    116116                kernelDef.appendChild(funcCall);
     
    129129    }
    130130
    131     private static InitDefNode makeInitDefNode(Locator locator,
     131    private static KernelInitDefNode makeKernelInitDefNode(Locator locator,
    132132            PropertyInfoSet propInfoSet) {
    133133       
    134         InitDefNode initDef = Generators.makeInitDefNode(locator);         
     134        KernelInitDefNode kernelInitDef = Generators.makeInitDefNode(locator);         
    135135       
    136136        // kernel properties
     
    138138        PropertyValueNode propertyValue     = Generators.makePropertyValueNode(locator, arrayFromList(propInfoSet.carry1InitialValues));
    139139        KernelPropertyNode property         = Generators.makeKernelPropertyNode(propertyName, propertyValue);
    140         initDef.appendChild(property);
     140        kernelInitDef.appendChild(property);
    141141
    142142        propertyName        = Generators.makeIdentifierNode(locator, KernelState.CARRY1_COUNT.name());
    143143        propertyValue       = Generators.makePropertyValueNode(locator, propInfoSet.carry1Count);
    144144        property            = Generators.makeKernelPropertyNode(propertyName, propertyValue);
    145         initDef.appendChild(property);
     145        kernelInitDef.appendChild(property);
    146146
    147147        ////////////////////////////////////////////////////////////
     
    155155        propertyValue      = Generators.makePropertyValueNode(locator, propInfoSet.carryNCount);
    156156        property           = Generators.makeKernelPropertyNode(propertyName, propertyValue);
    157         initDef.appendChild(property);
     157        kernelInitDef.appendChild(property);
    158158
    159159        propertyName       = Generators.makeIdentifierNode(locator, KernelState.LOOK_AHEAD.name());
    160160        propertyValue      = Generators.makePropertyValueNode(locator, propInfoSet.lookAhead);
    161161        property           = Generators.makeKernelPropertyNode(propertyName, propertyValue);
    162         initDef.appendChild(property);
     162        kernelInitDef.appendChild(property);
    163163
    164164        propertyName       = Generators.makeIdentifierNode(locator, KernelState.LOOK_BEHIND.name());
    165165        propertyValue      = Generators.makePropertyValueNode(locator, propInfoSet.lookBehind);
    166166        property           = Generators.makeKernelPropertyNode(propertyName, propertyValue);
    167         initDef.appendChild(property);
    168        
    169         return initDef;
     167        kernelInitDef.appendChild(property);
     168       
     169        return kernelInitDef;
    170170    }
    171171   
    172     private static FuncDefNode makeClearFuncDefNode(Locator locator, String funcName) {
    173         FuncDefNode funcDef = Generators.makeFuncDefNode(locator, funcName);
     172    private static KernelFuncDefNode makeClearKernelFuncDefNode(Locator locator, String funcName) {
     173        KernelFuncDefNode funcDef = Generators.makeKernelFuncDefNode(locator, funcName);
    174174        return funcDef;
    175175    }
     
    223223        //
    224224        public ASTNode visitLeave(s2k.ast.FilterParameterListNode snode, List<ASTNode> childResults) {
    225                 ASTNode replacement = Generators.makeParameterListNode(Generators.makeToken(snode.getToken()));
     225                ASTNode replacement = Generators.makeKernelParameterListNode(Generators.makeToken(snode.getToken()));
    226226                appendChildResults(replacement, childResults);
    227227                return replacement;             
     
    231231        // FilterParameterModeNode
    232232        public ASTNode visitLeave(s2k.ast.FilterParameterModeNode snode, List<ASTNode> childResults) {
    233                 ASTNode replacement = Generators.makeParameterModeNode(Generators.makeToken(snode.getToken()));
     233                ASTNode replacement = Generators.makeKernelParameterModeNode(Generators.makeToken(snode.getToken()));
    234234                return replacement;             
    235235        }
     
    237237       
    238238        public ASTNode visitLeave(s2k.ast.FilterParameterNode snode, List<ASTNode> childResults) {
    239                 ASTNode replacement = Generators.makeParameterNode(Generators.makeToken(snode.getToken()));
     239                ASTNode replacement = Generators.makeKernelParameterNode(Generators.makeToken(snode.getToken()));
    240240                appendChildResults(replacement, childResults);
    241241                return replacement;
     
    244244        public ASTNode visitLeave(s2k.ast.FilterDefNode snode, List<ASTNode> childResults) {
    245245           
    246             ASTNode replacement = new FuncDefNode(Generators.makeToken(snode.getToken()));
     246            ASTNode replacement = new KernelFuncDefNode(Generators.makeToken(snode.getToken()));
    247247            appendChildResults(replacement, childResults);
    248248           
     
    250250
    251251            if(needsCarryAdjustment(context, carry1Count) ) { 
    252                 addCarryAdjustment((FuncDefNode) replacement, context, carry1Count);
     252                addCarryAdjustment((KernelFuncDefNode) replacement, context, carry1Count);
    253253            }
    254254                       
    255255            if(context.isFinalBlockMode()) {
    256                 if(!hasEOFMaskParameter((FuncDefNode)replacement)) {
    257                     b2k.ast.ParameterNode EOFMaskParameter = Generators.makeEofMaskParameter(replacement);
    258                     Generators.appendParameter((FuncDefNode) replacement, EOFMaskParameter);
     256                if(!hasEOFMaskParameter((KernelFuncDefNode)replacement)) {
     257                    b2k.ast.KernelParameterNode EOFMaskParameter = Generators.makeEofMaskParameter(replacement);
     258                    Generators.appendParameter((KernelFuncDefNode) replacement, EOFMaskParameter);
    259259                }
    260260            }
     
    267267        }
    268268
    269         private void addCarryAdjustment(FuncDefNode node, Context context, int carry1Count) {
     269        private void addCarryAdjustment(KernelFuncDefNode node, Context context, int carry1Count) {
    270270            FuncCallNode carryAdjustment = Generators.makeCarryAdjustmentCall(node, context, carry1Count);
    271271            ASTNode body = Accessors.body(node);
     
    273273        }       
    274274       
    275         private boolean hasEOFMaskParameter(FuncDefNode node) {
     275        private boolean hasEOFMaskParameter(KernelFuncDefNode node) {
    276276            if(Accessors.hasParameters(node)) {
    277                 ParameterListNode parameterList = Accessors.parameterListNode(node);
     277                KernelParameterListNode parameterList = Accessors.parameterListNode(node);
    278278                ASTNode lastParameter = parameterList.lastChild();
    279279
Note: See TracChangeset for help on using the changeset viewer.