source: proto/s2k/trunk/framework/input/grammar/scatter/s2k.scatter @ 3769

Last change on this file since 3769 was 3769, checked in by ksherdy, 4 years ago

Added filter to s2k. Minor changes to s2k and b2k grammar.

File size: 8.4 KB
Line 
1// s2k - A domain specific language for streaming text extraction and transformations.
2//
3// Original:    2012/09/08       
4// Modified:    2014/03/29    Removed VOID type.     
5//
6// Tom Shermer, Ken Herdy
7//
8
9types {
10    toolchain.s2k.lang.signatures.FunctionSignature,
11    toolchain.s2k.lang.type.Type,
12    toolchain.s2k.lang.type.PrimitiveType,
13    toolchain.s2k.lang.type.StreamType,
14    toolchain.s2k.semanticAnalyzer.Binding,
15    toolchain.s2k.semanticAnalyzer.SymbolTable,
16}
17
18context main {
19
20    recognizers {
21        Whitespace [IGNORE],
22        Integer [INTEGER_CONST],
23        Identifier [IDENTIFIER],        // Java identifiers, except $ character. Produces Lextant tokens for keywords.
24        Comment [IGNORE] "#" "\n",      // Support parabix2_pablo debugging.
25        Comment [IGNORE] "//" "\n",
26        Comment [SQ_STRING] "'" "'",
27        Comment [IGNORE] "/*" "*/",     // Comment. Comment [STRING] "/*" "*/",
28        String [STRING],
29        Punctuator,
30        EndOfInput,
31    }
32
33  // t o k e n s
34    tokens {
35        FILTER,
36        IN,
37        OUT,
38        INOUT,
39        STREAM,
40        STRUCT,
41        INT,
42        IF,
43        ELSE,
44        WHILE,
45        RETURN,
46        AND             "&",
47        OR              "|",
48        NOT             "~",
49        XOR             "^",
50        MULTIPLY        "*",
51        DIVIDE          "/",
52        ADD             "+",
53        SUBTRACT        "-",
54        ASSIGN          "=",
55        AND_ASSIGN      "&=",
56        OR_ASSIGN       "|=",
57        XOR_ASSIGN      "^=",
58        MULTIPLY_ASSIGN "*=",
59        DIVIDE_ASSIGN   "/=",
60        ADD_ASSIGN      "+=",
61        SUBTRACT_ASSIGN "-=",
62        LANGLE          "<",
63        RANGLE          ">",
64        LCURLY          "{",
65        RCURLY          "}",
66        LROUND          "(",
67        RROUND          ")",
68        COMMA           ",",
69        TERMINATOR      ";",
70        DOT             ".",
71    }
72}
73
74interfaces {
75    intValued       {int value = 0;},
76    hasSymbolTable  {SymbolTable symbolTable = null;},
77    hasBinding      {Binding binding = null;},
78    hasFieldWidth   {int fieldWidth = 1;},
79    hasSignature    {FunctionSignature signature = null;},
80}
81
82nodes {
83    ASTNode                 {Type type = null;}  [assignOperator],
84    program                 {hasSymbolTable;} [],
85    structDecl              {hasSymbolTable;} [],
86    filterDef               {hasSymbolTable;} [],
87    blockStmt               {hasSymbolTable;} [],
88    identifier              {hasBinding;} [],
89    compoundIdentifier      {hasBinding;} [],
90    binaryOperator          {hasSignature;} [expr expr1 expr3 expr4],
91    unaryOperator           {hasSignature;} [expr2],
92    funcCall                {hasSignature;} [funcCallRest],
93//  parameterizedFuncCall   {hasSignature;} [idisaFuncCallRest],
94    assign                  {} [assignRest],
95    streamType              {hasFieldWidth;} [],
96    integerConstant         {intValued;}    [fieldWidthSpecifier],
97//  primitiveType           {} [intType voidType], // TODO - update S2K2B2k to handle primitiveType
98}
99
100grammar {
101
102    program     -> (structDecl | filterDef) *;    // ( filterDef )* graph;
103
104    //
105    // s t r e a m   s t r u c t   d e f i n i t i o n s
106    //
107    structDecl          ->  STRUCT structName structDeclBody TERMINATOR? ;
108    structDeclBody      ->  LCURLY (structMember TERMINATOR)+ RCURLY ;
109    structMember        ->  structMemberType structMemberName ;
110    structMemberType    #-> streamType ;
111    structMemberName    #-> identifier ;
112
113    // KH: user-defined stream functions?
114    //
115    // 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 
116    //
117    //funcDef             ->  FUNCTION returnType filterName LROUND parameterList RROUND blockStmt TERMINATOR? ;
118    //returnType          ->  type;                     
119    //parameterList       ->  (parameter (COMMA parameter)*)?;
120    //funcName            #-> identifier ;
121    //parameter           ->  type parameterName ;
122    //parameterName       #-> identifier ;
123
124    //
125    // 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
126    //
127    filterDef             ->  FILTER filterName LROUND filterParameterList RROUND blockStmt TERMINATOR? ;               
128    filterName            #-> identifier ;
129    filterParameterList   ->  ( filterParameter (COMMA filterParameter)* ) ? ;
130    filterParameter       ->  filterParameterMode? type filterParameterName ;
131    filterParameterMode   ->  (IN | OUT | INOUT) ; // KH: not implemented
132    filterParameterName   #-> identifier ;
133
134    //
135    // s t a t e m e n t s
136    //
137    stmt                        #->     varDecl | funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt  ;
138    blockStmt                   ->      LCURLY stmt* RCURLY ;
139    varDecl                     ->      type varName (ASSIGN^ expr) ? TERMINATOR ;
140    varName                     #->     identifier ; 
141    funcCallOrAssignStmt        #->     expr (assignRest _promote_) ? TERMINATOR ; // KH: SA must validate 'expr' is a 'funcCall'
142    assignRest                  ->      assignOperator^! expr ;
143    assignOperator              ->      ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN |
144                                        MULTIPLY_ASSIGN | DIVIDE_ASSIGN | ADD_ASSIGN | SUBTRACT_ASSIGN ;       
145    ifStmt                      ->      IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                         
146    whileStmt                   ->      WHILE LROUND expr RROUND blockStmt ;
147    returnStmt                  ->      RETURN (expr)? TERMINATOR ;
148
149  //forStmt       -> FOR LROUND elementName IN expr RROUND blockStmt ; // expr?
150  //elementName   #-> identifier ;
151
152  //annotationStmt    -> AMPERSAND annotationName LROUND annotationArgList RROUND blockStmt TERMINATOR ;
153  //annotationArgList -> (expr (COMMA expr)*) ?   
154
155    //
156    // e x p r e s s i o n s
157    //   
158    expr        #-> expr1 ((OR^|XOR^) expr)? _leftAssoc_ ;
159    expr1       #-> expr2 ((AND^) expr1)? _leftAssoc_ ;
160    expr2       #-> NOT^^? expr3;                                         
161    expr3       #-> expr4 ((MULTIPLY^ | DIVIDE^) expr3)? _leftAssoc_ ;
162    expr4       #-> expr5 ((ADD^ | SUBTRACT^) expr4)? _leftAssoc_ ;
163    expr5       #-> LROUND expr RROUND
164                | constant
165                | compoundIdentifier (funcCallRest _promote_) ? ; // | compoundIdentifier ((funcCallRest _promote_) | (parameterizedFuncCallRest _promote_)) ? ;
166
167// fieldWidthSpecifier
168
169//    parameterizedFuncCallRest         ->      LANGLE fieldWidth RANGLE LROUND idisaFuncCallArgList RROUND;
170//    fieldWidth                        #->     (LANGLE integer RANGLE ) ;   
171                                                                                                                                   
172    constant                #-> stringConstant | integerConstant ;
173    integerConstant         ->     INTEGER_CONST {@value = @@value;} ;
174    stringConstant          ->     STRING | SQ_STRING ;   
175    compoundIdentifier      #-> identifier (DOT^ identifier)?;
176    identifier              ->     IDENTIFIER ;
177    funcCallRest            ->     LROUND^ funcCallArgList RROUND ;
178    funcCallArgList         ->     (expr (COMMA expr)*) ? ;     
179
180// TODO - idisa function call simd.popcount<>(); -> simd.popcount<128>() + ... + simd.popcount<128>()
181//
182//        package.name - if 'esimd' then ...
183//
184
185    //
186    // t y p e s
187    //
188    type                    #->     primitiveType   |
189                                    streamType      |
190                                    structType;
191
192    primitiveType           #->     ( intType ) ;
193    intType                 ->      INT    { @type = {{PrimitiveType.INTEGER}};  } ;
194    streamType              ->      STREAM fieldWidthSpecifier! {   @fieldWidth = @:value;
195                                                                    @type = {{ StreamType.STREAM(%?) }} , @fieldWidth ;
196                                                                } ;
197                   
198    fieldWidthSpecifier     #->      (LANGLE integerConstant RANGLE ) | (epsilon {@value = 1;}) ;   
199    structType              ->       STRUCT structName ;       
200    structName              #->      identifier ;               
201
202    //
203    // s t r e a m   g r a p h
204    //
205
206    // graph              ->  LCURLY filterCall* RCURLY TERMINATOR ? ;  // add varDecl* first impl
207    // filterCall         ->  filterName LROUND RROUND TERMINATOR ;
208    // filterCallArgList  ->  (expr (COMMA expr)*) ? ; 
209
210    //graph {
211    //  doProcess(fread("fin"), fwrite("out));
212    //} 
213
214}
Note: See TracBrowser for help on using the repository browser.