Changeset 3782


Ignore:
Timestamp:
Apr 3, 2014, 7:36:49 PM (4 years ago)
Author:
ksherdy
Message:

Added graph to b2k. Updated grammars. Added S2K to B2K support.

Location:
proto/s2k/trunk/framework
Files:
4 deleted
13 edited

Legend:

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

    r3778 r3782  
    3535    // t o k e n s
    3636    tokens {
     37        GRAPH,
    3738        INIT,
    3839        KERNEL,
     
    7677    idisaFuncCall {} [idisaFuncCallRest],
    7778    integerConstant{intValued;} [fieldWidthSpecifier ], // codeBlockWidthSpecifier ],
    78     // primitiveType{} [intType voidType boolType bitBlockType], // TODO - update S2B to handle this
     79    // primitiveType{} [intType voidType boolType bitBlockType], // KH: update S2B
    7980    fieldWidthType{int fieldWidth = 1;} [],
    8081    // codeBlockWidth{int codeBlockWidth = 128;} [],
     
    119120    kernelFuncBody      #-> blockStmt ;
    120121    carryDeclare                #-> expr; // KH: temp hack to append the CarryDeclare() macro
     122
     123    //
     124    // s t r e a m   g r a p h  ( p i p e l i n e )  d e f i n i t i o n
     125    //   
     126    graphDef                    ->  GRAPH graphName LROUND graphParameterList RROUND graphBody TERMINATOR ? ;
     127   
     128    graphName                   #-> identifier ;
     129    graphParameterList          ->  ( graphParameter (COMMA graphParameter)* ) ? ; // KH: implement as a 'modal' parameter
     130    graphParameter              ->  graphParameterMode? type graphParameterName ;
     131    graphParameterMode          ->  (IN | OUT | INOUT) ;
     132    graphParameterName          #-> identifier ;
     133   
     134    graphBody                   ->  LCURLY graphVarDecl * addKernelStmt RCURLY ;
     135   
     136    graphVarDecl                #-> structDecl | kernelDecl ;
     137    structDecl                  ->  structType structName TERMINATOR ;
     138    kernelDecl                  ->  kernelType kernelName TERMINATOR ;
     139    // graphDecl                ->  GRAPH graphName TERMINATOR ;
     140       
     141    addKernelStmt               ->  kernelVarName kernelArgList ;
     142    kernelVarName               #-> identifier ;
     143    kernelArgList               ->  (kernelArgName (COMMA kernelArgName) *) ? ;
     144    kernelArgName               #-> identifier ; 
    121145
    122146    //
     
    166190    type                #-> primitiveType   |
    167191                            bitFieldType    |
    168                             structType ;
     192                            structType      |
     193                            kernelType      ;
    169194
    170195    primitiveType       #->  ( intType | voidType | boolType | bitBlockType ) ;
     
    183208                            | (epsilon {@value = 1;}) ;
    184209   
    185     structType              ->  STRUCT structName ;
    186     structName              #-> identifier ;
    187    
    188 }
     210    structType             ->  STRUCT structName ;
     211    structName             #-> identifier ;
     212   
     213    kernelType             -> KERNEL kernelName ;
     214    kernelName             #-> identifier ;
     215   
     216}
  • proto/s2k/trunk/framework/input/grammar/scatter/s2k.scatter

    r3777 r3782  
    3838  // t o k e n s
    3939    tokens {
     40        GRAPH,   
    4041        FILTER,
    4142        IN,
     
    5556        MULTIPLY        "*",
    5657        DIVIDE          "/",
    57         ADD             "+",
    58         SUBTRACT        "-",
     58        PLUS            "+",
     59        MINUS           "-",
    5960        ASSIGN          "=",
    6061        AND_ASSIGN      "&=",
     
    6364        MULTIPLY_ASSIGN "*=",
    6465        DIVIDE_ASSIGN   "/=",
    65         ADD_ASSIGN      "+=",
    66         SUBTRACT_ASSIGN "-=",
     66        PLUS_ASSIGN     "+=",
     67        MINUS_ASSIGN    "-=",
    6768        LANGLE          "<",
    6869        RANGLE          ">",
     
    105106grammar {
    106107
    107     program     -> (structDef | filterDef) *;    // ( filterDef )* graph;
    108 
    109     //
    110     // s t r e a m   s t r u c t   d e f i n i t i o n s
     108    program     -> ( structDef | filterDef ) * graphDef * ;
     109
     110    //
     111    // s t r e a m   s t r u c t   d e f i n i t i o n
    111112    //
    112113    structDef             ->  STRUCT structName structDefBody TERMINATOR? ;
     
    118119    // KH: user-defined stream functions?
    119120    //
    120     // s t r e a m   f u n c t i o n   d e f i n i t i o n s 
    121     //
    122     //funcDef             ->  FUNCTION returnType filterName LROUND parameterList RROUND blockStmt TERMINATOR? ;
    123     //returnType          ->  type;                     
    124     //parameterList       ->  (parameter (COMMA parameter)*)?;
    125     //funcName            #-> identifier ;
    126     //parameter           ->  type parameterName ;
    127     //parameterName       #-> identifier ;
    128 
    129     //
    130     // s t r e a m   f i l t e r   ( p r o c e d u r e )  d e f i n i t i o n s
    131     //
    132     filterDef             ->  FILTER filterName LROUND filterParameterList RROUND blockStmt TERMINATOR? ;               
    133     filterName            #-> identifier ;
    134     filterParameterList   ->  ( filterParameter (COMMA filterParameter)* ) ? ;
    135     filterParameter       ->  filterParameterMode? type filterParameterName ;
    136     filterParameterMode   ->  (IN | OUT | INOUT) ; // KH: not implemented
    137     filterParameterName   #-> identifier ;
     121    // s t r e a m   f u n c t i o n   d e f i n i t i o n   
     122    //
     123    //funcDef             ->  FUNCTION funcReturnType funcName LROUND funcParameterList RROUND funcBody TERMINATOR? ;
     124    //funcReturnType      #-> type;                     
     125    //funcParameterList   ->  ( funcParameter (COMMA funcParameter)* ) ? ;
     126    //funcPName           #-> identifier ;
     127    //funcParameter       ->  type funcParameterName ;
     128    //funcParameterName   #-> identifier ;
     129
     130    //
     131    // s t r e a m   f i l t e r   ( p r o c e d u r e )  d e f i n i t i o n
     132    //
     133    filterDef                   ->  FILTER filterName LROUND filterParameterList RROUND blockStmt TERMINATOR? ;               
     134    filterName                  #-> identifier ;
     135    filterParameterList         ->  ( filterParameter (COMMA filterParameter)* ) ? ;
     136    filterParameter             ->  filterParameterMode? type filterParameterName ;
     137    filterParameterMode         ->  (IN | OUT | INOUT) ; // KH: not implemented
     138    filterParameterName         #-> identifier ;
     139
     140    //
     141    // s t r e a m   g r a p h  ( p i p e l i n e )  d e f i n i t i o n
     142    //   
     143    graphDef                    ->  GRAPH graphName LROUND graphParameterList RROUND graphBody TERMINATOR ? ;
     144   
     145    graphName                   #-> identifier ;
     146    graphParameterList          ->  ( graphParameter (COMMA graphParameter)* ) ? ; // KH: implement as a 'modal' parameter
     147    graphParameter              ->  graphParameterMode? type graphParameterName ;
     148    graphParameterMode          ->  (IN | OUT | INOUT) ;
     149    graphParameterName          #-> identifier ;
     150   
     151    graphBody                   ->  LCURLY graphVarDecl * addFilterStmt * RCURLY ;
     152   
     153    graphVarDecl                #->  structDecl | filterDecl ;
     154    structDecl                  ->  structType structName TERMINATOR ;
     155    filterDecl                  ->  filterType filterName TERMINATOR ;
     156    // graphDecl                ->  GRAPH graphName TERMINATOR ;
     157   
     158    addFilterStmt                   ->  filterVarName LROUND filterArgList RROUND TERMINATOR ;
     159    filterVarName               #-> identifier ;
     160    filterArgList               ->  (filterArgName (COMMA filterArgName) *) ? ;
     161    filterArgName               #-> identifier ; 
    138162
    139163    //
     
    147171    assignRest                  ->      assignOperator^! expr ;
    148172    assignOperator              ->      ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN |
    149                                         MULTIPLY_ASSIGN | DIVIDE_ASSIGN | ADD_ASSIGN | SUBTRACT_ASSIGN ;       
     173                                        MULTIPLY_ASSIGN | DIVIDE_ASSIGN | PLUS_ASSIGN | MINUS_ASSIGN ;       
    150174    ifStmt                      ->      IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                         
    151175    whileStmt                   ->      WHILE LROUND expr RROUND blockStmt ;
     
    165189    expr2       #-> NOT^^? expr3;                                         
    166190    expr3       #-> expr4 ((MULTIPLY^ | DIVIDE^) expr3)? _leftAssoc_ ;
    167     expr4       #-> expr5 ((ADD^ | SUBTRACT^) expr4)? _leftAssoc_ ;
     191    expr4       #-> expr5 ((PLUS^ | MINUS^) expr4)? _leftAssoc_ ;
    168192    expr5       #-> LROUND expr RROUND
    169193                | constant
     
    176200                                                                                                                                   
    177201    constant                #-> stringConstant | integerConstant ;
    178     integerConstant         ->     INTEGER_CONST {@value = @@value;} ;
    179     stringConstant          ->     STRING | SQ_STRING ;   
     202    integerConstant         ->  INTEGER_CONST {@value = @@value;} ;
     203    stringConstant          ->  STRING | SQ_STRING ;   
    180204    compoundIdentifier      #-> identifier (DOT^ identifier)?;
    181     identifier              ->     IDENTIFIER ;
    182     funcCallRest            ->     LROUND^ funcCallArgList RROUND ;
    183     funcCallArgList         ->     (expr (COMMA expr)*) ? ;     
     205    identifier              ->  IDENTIFIER ;
     206    funcCallRest            ->  LROUND^ funcCallArgList RROUND ;
     207    funcCallArgList         ->  (expr (COMMA expr)*) ? ;     
    184208
    185209// TODO - idisa function call simd.popcount<>(); -> simd.popcount<128>() + ... + simd.popcount<128>()
     
    193217    type                    #->     primitiveType   |
    194218                                    streamType      |
    195                                     structType;
     219                                    structType      |
     220                                    filterType      ;
    196221
    197222    primitiveType           #->     ( intType ) ;
     
    205230    structName              #->      identifier ;               
    206231
    207     //
    208     // s t r e a m   g r a p h
    209     //
    210 
    211     // graph              ->  LCURLY filterCall* RCURLY TERMINATOR ? ;  // add varDecl* first impl
    212     // filterCall         ->  filterName LROUND RROUND TERMINATOR ;
    213     // filterCallArgList  ->  (expr (COMMA expr)*) ? ; 
    214 
    215     //graph {
    216     //  doProcess(fread("fin"), fwrite("out));
    217     //} 
    218 
    219 }
     232    filterType              ->       FILTER filterName ;       
     233    filterName              #->      identifier ;
     234}
  • proto/s2k/trunk/framework/input/templates/cpplang/grep_definitions.template

    r3760 r3782  
    1717#define GREP_DEFINITIONS_HPP
    1818
     19//
    1920// runtime libraries
    2021#include <simd-lib/bitblock.hpp>
     
    2425
    2526//
    26 //#include <simd-lib/transpose.hpp>
     27#define BASIS_BITS
     28#include <simd-lib/transpose.hpp>
    2729//#include <simd-lib/s2p.hpp>
    2830
     
    3335
    3436#endif // GREP_DEFINITIONS_HPP
     37
  • proto/s2k/trunk/framework/input/test/b2k/all/all.b2k

    r3762 r3782  
    4040                r = hsimd.add_hl<2>(a);                 
    4141       
    42         r = simd.add(abs);
     42        r = simd.sub(abs);
    4343        /*
    4444        r = simd.neg(a);
  • proto/s2k/trunk/framework/input/test/s2k/all/all.s2k

    r3770 r3782  
    1 struct BasisBits {
    2         stream<1> b1;
    3         stream<1> b2;
    4         stream<1> b3;
    5         stream<1> b4;
    6 };
    7 struct BasisBits {
    8         stream<1> b1;
    9         stream<1> b2;
    10         stream<1> b3;
    11         stream<1> b4;
    12 };
    13 
    14 filter Foo() {
    15 
    16 }filter AssignmentExpressions() {       
     1filter AssignmentExpressions() {       
    172        temp4 = temp;
    183        temp4 &= temp1 | temp2;
     
    163148}
    164149
    165 
     150/*
    166151struct Basis_bits{
    167152    stream bit_0;
     
    174159    stream bit_7;
    175160};
     161*/
    176162
    177163struct Lex{
     
    246232}
    247233
    248 /*
    249 filter Main(struct Basis_bits basis_bits, struct Lex lex, struct Output output) {
    250     Transpose(byte_data, basis_bits);
    251     ClassifyBytes(basis_bits, lex);
    252     Match(lex, output);
    253     MatchLines(lex, output);
    254 }
    255 */
     234
     235graph Main() {
     236
     237    struct Byte_data byte_data;
     238    struct Basis_bits basis_bits;
     239    struct Lex lex;
     240    struct Output output;
     241    struct MatchLines matchLines;
     242   
     243    filter Transpose transpose;
     244    filter ClassifyBytes classifyBytes;
     245    filter Match match;
     246    filter MatchLines matchLines;
     247
     248    transpose(byte_data, basis_bits);
     249    classifyBytes(basis_bits, lex);
     250    match(lex, output);
     251    matchLines(lex, output);
     252   
     253}
     254
    256255
    257256struct Basis_bits{
     
    728727    check_streams.name_follows = (tag_Callouts.ElemName_ends | tag_Callouts.AttName_ends);
    729728    check_streams.att_refs = (tag_Callouts.AttVal_spans & marker.Ref_opener);
    730 }struct bb {
    731         stream<1> a;
    732 
    733 };
    734 
    735 /*
    736 filter name(stream<1> a, stream<1> b, stream<1> c) {
    737 
    738 
    739 };
    740 */
    741 struct B
    742 {
    743         stream<1> a;
    744         stream<1> a;
    745         stream<1> a;
    746         stream<1> a;
    747 };
    748 
    749 filter Foo() { }
    750 filter ClassifyBytes(struct BasisBit basis) {};
    751 
     729}
    752730
    753731struct Basis{
     
    861839    return pablo.PopCount((pablo.MatchStar(lines, (~ lex.LF)) & lex.LF)) ;
    862840}
     841struct BasisBits {
     842        stream<1> b1;
     843        stream<1> b2;
     844        stream<1> b3;
     845        stream<1> b4;
     846};
     847
     848filter Foo() {
     849
     850}struct BasisBits {
     851        stream<1> b1;
     852        stream<1> b2;
     853        stream<1> b3;
     854        stream<1> b4;
     855};
     856filter ClassifyBytes(struct BasisBit basis) {};
     857struct B
     858{
     859        stream<1> a;
     860        stream<1> a;
     861        stream<1> a;
     862        stream<1> a;
     863};
     864
     865filter Foo() { }
     866struct bb {
     867        stream<1> a;
     868
     869};
     870
     871/*
     872filter name(stream<1> a, stream<1> b, stream<1> c) {
     873
     874
     875};
     876*/
    863877/*
    864878        Block comment.
  • proto/s2k/trunk/framework/input/test/s2k/proto/grep/grep.s2k

    r3767 r3782  
    11
    2 
     2/*
    33struct Basis_bits{
    44    stream bit_0;
     
    1111    stream bit_7;
    1212};
     13*/
    1314
    1415struct Lex{
     
    8384}
    8485
    85 /*
    86 filter Main(struct Basis_bits basis_bits, struct Lex lex, struct Output output) {
    87     Transpose(byte_data, basis_bits);
    88     ClassifyBytes(basis_bits, lex);
    89     Match(lex, output);
    90     MatchLines(lex, output);
     86
     87graph Main() {
     88
     89    struct Byte_data byte_data;
     90    struct Basis_bits basis_bits;
     91    struct Lex lex;
     92    struct Output output;
     93    struct MatchLines matchLines;
     94   
     95    filter Transpose transpose;
     96    filter ClassifyBytes classifyBytes;
     97    filter Match match;
     98    filter MatchLines matchLines;
     99
     100    transpose(byte_data, basis_bits);
     101    classifyBytes(basis_bits, lex);
     102    match(lex, output);
     103    matchLines(lex, output);
     104   
    91105}
    92 */
  • proto/s2k/trunk/framework/output/cpplang/grep/grep_definitions.hpp

    r3761 r3782  
    1717#define GREP_DEFINITIONS_HPP
    1818
     19//
    1920// runtime libraries
    2021#include <simd-lib/bitblock.hpp>
     
    2425
    2526//
    26 //#include <simd-lib/transpose.hpp>
     27#define BASIS_BITS
     28#include <simd-lib/transpose.hpp>
    2729//#include <simd-lib/s2p.hpp>
    2830
    2931// namespace s2k
    3032// {
    31 struct Basis_bits
    32 {
    33         BitBlock bit_0;
    34         BitBlock bit_1;
    35         BitBlock bit_2;
    36         BitBlock bit_3;
    37         BitBlock bit_4;
    38         BitBlock bit_5;
    39         BitBlock bit_6;
    40         BitBlock bit_7;
    41 };
    42  
    4333struct Lex
    4434{
     
    345335
    346336#endif // GREP_DEFINITIONS_HPP
     337
  • proto/s2k/trunk/framework/src/application/generators/AbstractTemplateContentsGenerator.java

    r3751 r3782  
    77package application.generators;
    88
    9 import toolchain.b2k.codeGenerator.visitors.AbstractUnparser;
     9import toolchain.b2k.codeGenerator.visitors.AbstractCodeGenerator;
    1010
    1111abstract public class AbstractTemplateContentsGenerator {
    1212   
    1313        protected b2k.ast.ProgramNode programNode;
    14         protected AbstractUnparser unparser;
     14        protected AbstractCodeGenerator unparser;
    1515    //protected String outputDirectory;
    1616        protected String templateFilePath;
     
    1818               
    1919        public AbstractTemplateContentsGenerator(b2k.ast.ProgramNode programNode,
    20                                                                                 AbstractUnparser unparser,
     20                                                                                AbstractCodeGenerator unparser,
    2121                //                                                              String outputDirectory,
    2222                                                                                String templateFilePath,
  • proto/s2k/trunk/framework/src/application/generators/ApplicationGenerator.java

    r3760 r3782  
    1111import toolchain.b2k.codeGenerator.idisa.IDISABuiltin2C;
    1212import toolchain.b2k.codeGenerator.idisa.IDISABuiltin2CPP;
    13 import toolchain.b2k.codeGenerator.visitors.AbstractUnparser;
    14 import toolchain.b2k.codeGenerator.visitors.Unparser;
     13import toolchain.b2k.codeGenerator.visitors.AbstractCodeGenerator;
     14import toolchain.b2k.codeGenerator.visitors.GlobalDefintionsCodeGenerator;
    1515import toolchain.b2k.transformer.visitors.B2K2B2K.B2K2B2KController;
    1616
     
    4242                toolchain.s2k.lang.BuiltinEncoder s2kBuiltinsEncoder  = null;
    4343                toolchain.b2k.lang.BuiltinEncoder b2kBuiltinsEncoder  = null;
    44                 AbstractUnparser unparser                                                                       = null;
     44                AbstractCodeGenerator globalDefsGenerator                                                                       = null;
    4545               
    4646                toolchain.s2k.lang.carrySet.CarrySetEncoder carrySetEncoder = null;
     
    4949            s2kBuiltinsEncoder  = new toolchain.s2k.lang.S2KBuiltin2C();
    5050            b2kBuiltinsEncoder  = new toolchain.b2k.lang.B2KBuiltins2C();
    51             carrySetEncoder             = new toolchain.s2k.lang.carrySet.CarrySetBuiltin2C();
    52                         unparser                        = new Unparser(new IDISABuiltin2C());                   
     51            carrySetEncoder     = new toolchain.s2k.lang.carrySet.CarrySetBuiltin2C();
     52                        globalDefsGenerator = new GlobalDefintionsCodeGenerator(new IDISABuiltin2C());                 
    5353                } else if(applicationConfiguration.getTarget() == Target.CPP_LANG) {
    5454                        s2kBuiltinsEncoder      = new toolchain.s2k.lang.S2KBuiltin2CPP();
    5555                        b2kBuiltinsEncoder      = new toolchain.b2k.lang.B2KBuiltins2CPP();
    56                         carrySetEncoder                 = new toolchain.s2k.lang.carrySet.CarrySetBuiltin2CPP();
    57                         unparser                                = new Unparser(new IDISABuiltin2CPP());
     56                        carrySetEncoder         = new toolchain.s2k.lang.carrySet.CarrySetBuiltin2CPP();
     57                        globalDefsGenerator     = new GlobalDefintionsCodeGenerator(new IDISABuiltin2CPP());
    5858                } /*else if(applicationConfiguration.targetLang.contentEquals(Configuration.LLVM)) {  // default C++
    5959                        builtins2Lang = new S2KBuiltins2CPP();
     
    105105                String outputFilePath           = applicationConfiguration.outputFilePath();
    106106               
    107                 HeaderTemplateContentsGenerator templateContentsGenerator
    108                                                                         = new HeaderTemplateContentsGenerator((b2k.ast.ProgramNode) b2kAST,
    109                                                                                                                                                         unparser,
     107                GlobalDefinitionsContentsGenerator globalTemplateContentsGenerator
     108                                                                        = new GlobalDefinitionsContentsGenerator((b2k.ast.ProgramNode) b2kAST,
     109                                                                                                                                                        globalDefsGenerator,
    110110//                                                                                                                                                      outputDirectory,
    111111                                                                                                                                                        templateFilePath,
    112112                                                                                                                                                        outputFilePath);       
    113                 templateContentsGenerator.generate();
     113                globalTemplateContentsGenerator.generate();
    114114               
    115115                printCompletionMessage(outputFilePath);
  • proto/s2k/trunk/framework/src/toolchain/b2k/ast/Generators.java

    r3778 r3782  
    6363                } else if (sToken instanceof s2k.tokens.LextantToken) {
    6464                       
     65                        if(sToken.isLextant(s2k.lexicalAnalyzer.Lextant.FILTER)) {
     66                                bToken = b2k.tokens.LextantToken.make(makeTextLocation(sToken.getLocation()),
     67                                                                                                                Lextant.KERNEL.getPrimaryLexeme(),
     68                                                                                                                Lextant.KERNEL);
     69                        } else {
     70                       
    6571                        bToken = b2k.tokens.LextantToken.make(makeTextLocation(sToken.getLocation()),
    6672                                                                                                        sToken.getLexeme(),
    67                                                                                                         b2k.lexicalAnalyzer.Lextant.forLexeme(sToken.getLexeme(), LEXICAL_CONTEXT));                                                                   
     73                                                                                                        b2k.lexicalAnalyzer.Lextant.forLexeme(sToken.getLexeme(), LEXICAL_CONTEXT));
     74                        }
    6875                       
    6976                } else if (sToken instanceof s2k.tokens.NullToken) {
     
    220227    // Function definitions
    221228    //
    222    
    223229    public static KernelFuncDefNode makeKernelFuncDefNode(Locator locator, String identifier) {
    224230       
  • proto/s2k/trunk/framework/src/toolchain/b2k/codeGenerator/idisa/AbstractIDISABuiltin2Lang.java

    r3702 r3782  
    2828import java.util.ArrayList;
    2929
    30 import toolchain.b2k.codeGenerator.util.UnparserUtil;
     30import toolchain.b2k.codeGenerator.util.CodeGeneratorUtil;
    3131
    3232public abstract class AbstractIDISABuiltin2Lang {
     
    4545                _firstArg = argList.get(0);
    4646               
    47                 String csv = UnparserUtil.makeDelimitedList(argList.subList(start, argList.size()), ",");
     47                String csv = CodeGeneratorUtil.makeDelimitedList(argList.subList(start, argList.size()), ",");
    4848                return csv;
    4949        }
  • proto/s2k/trunk/framework/src/toolchain/s2k/lang/signatures/OperatorSignatures.java

    r3711 r3782  
    1717       
    1818        static {
    19                 put(Lextant.ADD, sig_SS_S());
     19                put(Lextant.PLUS, sig_SS_S());
    2020        }
    2121
  • proto/s2k/trunk/framework/src/toolchain/s2k/transformer/visitors/S2K2B2K/S2K2B2KTransformer.java

    r3778 r3782  
    218218        // s2k to b2k translation (special cases)
    219219        ////////////////////////////////////////////////////////////////////////////////////
    220        
    221         ////////////////////////////////////////////////////////////////////////////////////
    222         // FilterDef
     220
     221        ////////////////////////////////////////////////////////////////////////////////////
     222        // GraphDef
     223        //       
     224       
     225        // KH: quick and dirty translations bypass b2k.ast.Generators and instead use 'new'
     226       
     227        // AddFilterStmtNode -> AddKernelStmtNode
     228        //
     229        public ASTNode visitLeave(s2k.ast.AddFilterStmtNode snode, List<ASTNode> childResults) {
     230                ASTNode replacement = new AddKernelStmtNode(Generators.makeToken(snode.getToken()));
     231                appendChildResults(replacement, childResults);
     232                return replacement;
     233        }
     234       
     235        // FilterArgList -> KernelArgListNode
     236        //
     237        public ASTNode visitLeave(s2k.ast.FilterArgListNode snode, List<ASTNode> childResults) {
     238                ASTNode replacement = new KernelArgListNode(Generators.makeToken(snode.getToken()));
     239                appendChildResults(replacement, childResults);
     240                return replacement;
     241        }
     242       
     243        // FilterDecl -> KernelDecl
     244        //
     245        public ASTNode visitLeave(s2k.ast.FilterDeclNode snode, List<ASTNode> childResults) {
     246                ASTNode replacement = new KernelDeclNode(Generators.makeToken(snode.getToken()));
     247                appendChildResults(replacement, childResults);
     248                return replacement;
     249        }
     250       
     251        // FilterType -> KernelType
     252        //
     253        public ASTNode visitLeave(s2k.ast.FilterTypeNode snode, List<ASTNode> childResults) {
     254                ASTNode replacement = new KernelTypeNode(Generators.makeToken(snode.getToken()));;
     255                appendChildResults(replacement, childResults);
     256                return replacement;
     257        }
     258       
     259        // FilterDefParmeterList -> KernelParameterList
    223260        //
    224261        public ASTNode visitLeave(s2k.ast.FilterParameterListNode snode, List<ASTNode> childResults) {
     
    228265        }
    229266       
    230         ////////////////////////////////////////////////////////////////////////////////////
    231         // FilterParameterModeNode
     267        // FilterParameterModeNode -> KernelParameterModeNode
     268        //
    232269        public ASTNode visitLeave(s2k.ast.FilterParameterModeNode snode, List<ASTNode> childResults) {
    233270                ASTNode replacement = Generators.makeKernelParameterModeNode(Generators.makeToken(snode.getToken()));
     
    235272        }
    236273
    237        
     274        // FilterParameterNode -> KernelParameterNode
     275        //
    238276        public ASTNode visitLeave(s2k.ast.FilterParameterNode snode, List<ASTNode> childResults) {
    239277                ASTNode replacement = Generators.makeKernelParameterNode(Generators.makeToken(snode.getToken()));
     
    242280        }
    243281       
     282        // FilterDefNode -> KernelFuncDef ( isFinalBlockMode )
     283        //
    244284        public ASTNode visitLeave(s2k.ast.FilterDefNode snode, List<ASTNode> childResults) {
    245285           
     
    298338        //  if (condition) { S* } => if (Any(condition)) { S* }
    299339        //
    300         //  Note: ANDC EOF_Mask is not applied to 'condition' because we test the position following the EOF for errors.
     340        //  Note: ANDC EOF_Mask is not applied to 'condition' because we test the follows position (for errors).
    301341        //
    302342        public ASTNode visitLeave(s2k.ast.IfStmtNode snode, List<ASTNode> childResults) {
Note: See TracChangeset for help on using the changeset viewer.