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

Last change on this file since 4115 was 4115, checked in by ksherdy, 5 years ago

Added comments.

File size: 10.2 KB
Line 
1// s2k - A domain specific language for streaming text extraction and transformations.
2//
3// 2012/09/08    Original definition.       
4// 2014/03/29    Removed VOID type as a return type.     
5// 2014/04/01    Added streamGraph.
6// 2014/15/04    Added foreach loop.
7// 2014/17/04    Added for loop.
8//
9// Tom Shermer <shermer at sfu dot ca>
10// Ken Herdy <ksherdy at sfu dot ca>
11//
12
13types {
14    toolchain.s2k.lang.signatures.FunctionSignature,
15    toolchain.s2k.lang.type.Type,
16    toolchain.s2k.lang.type.PrimitiveType,
17    toolchain.s2k.lang.type.StreamType,
18    toolchain.s2k.semanticAnalyzer.Binding,
19    toolchain.s2k.semanticAnalyzer.SymbolTable,
20}
21
22context main {
23
24    recognizers {
25        Whitespace [IGNORE],
26        Integer    [INTEGER_CONST],
27        Identifier [IDENTIFIER],        // Java identifiers, except $ character. Produces Lextant tokens for keywords.
28        Comment    [IGNORE] "#" "\n",   // Support parabix2_pablo debugging.
29        Comment    [IGNORE] "//" "\n",
30        Comment    [SQ_STRING] "'" "'",
31        Comment    [IGNORE] "/*" "*/",  // Comment. Comment [STRING] "/*" "*/",
32        String     [STRING],
33        Punctuator,
34        EndOfInput,
35    }
36
37  // t o k e n s
38    tokens {
39        GRAPH,   
40        FILTER,
41        IN,
42        OUT,
43        INOUT,
44        STREAM,
45        STRUCT,
46        INT,
47        IF,
48        ELSE,
49        WHILE,
50        FOR,         
51        BY,       
52        FOREACH,
53        RETURN,
54        AND             "&",
55        OR              "|",
56        NOT             "~",
57        XOR             "^",
58        MULTIPLY        "*",
59        DIVIDE          "/",
60        PLUS            "+",
61        MINUS           "-",
62        ASSIGN          "=",
63        AND_ASSIGN      "&=",
64        OR_ASSIGN       "|=",
65        XOR_ASSIGN      "^=",
66        MULTIPLY_ASSIGN "*=",
67        DIVIDE_ASSIGN   "/=",
68        PLUS_ASSIGN     "+=",
69        MINUS_ASSIGN    "-=",
70        LANGLE          "<",
71        RANGLE          ">",
72        LCURLY          "{",
73        RCURLY          "}",
74        LROUND          "(",
75        RROUND          ")",
76        COMMA           ",",
77        TERMINATOR      ";",
78        DOT             ".",
79        DDOT            "..",
80        COLON           ":",
81    }
82}
83
84interfaces {
85    intValued       {int value = 0;},
86    hasSymbolTable  {SymbolTable symbolTable = null;},
87    hasBinding      {Binding binding = null;},
88    hasFieldWidth   {int fieldWidth = 1;},
89    hasSignature    {FunctionSignature signature = null;},
90}
91
92nodes {
93    ASTNode                 {Type type = null;}  [assignOperator],
94    program                 {hasSymbolTable;} [],
95    structDef               {hasSymbolTable;} [],
96    filterDef               {hasSymbolTable;} [],
97    blockStmt               {hasSymbolTable;} [],
98    identifier              {hasBinding;}     [],
99    compoundIdentifier      {hasBinding;}     [],
100    unaryOperator           {hasSignature;}   [expr5],
101    binaryOperator          {hasSignature;}   [expr expr1 expr2 expr3 expr4],
102    assign                  {}                [assignRest],
103    funcCall                {hasSignature;}   [funcCallRest],
104    idisaFuncCall           {hasSignature;}   [idisaFuncCallRest],
105    streamType              {hasFieldWidth;}  [],
106    integerConstant         {intValued;}      [fieldWidthSpecifier],
107    step                    {intValued;}      [],
108//  primitiveType           {}                [intType voidType], // KH: update S2K2B2k for primitiveType
109                       
110}
111
112grammar {
113
114    program     -> ( structDef | filterDef ) * graphDef ? ;
115
116    //
117    // s t r e a m   s t r u c t   d e f i n i t i o n
118    //
119    structDef             ->  STRUCT identifier structDefBody TERMINATOR? ;
120    structDefBody         ->  LCURLY (structMember TERMINATOR)+ RCURLY ;
121    structMember          ->  structMemberType identifier ;
122    structMemberType      #-> streamType ;
123
124    // KH: user-defined stream functions?
125    //
126    // s t r e a m   f u n c t i o n   d e f i n i t i o n   
127    //
128    //funcDef             ->  FUNCTION funcReturnType identifier LROUND funcParameterList RROUND funcBody TERMINATOR? ;
129    //funcReturnType      #-> type;                     
130    //funcParameterList   ->  ( funcParameter (COMMA funcParameter)* ) ? ;
131    //funcParameter       ->  type identifier ;
132
133    //
134    // 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
135    //
136    filterDef                   ->  FILTER identifier LROUND filterParameterList RROUND blockStmt TERMINATOR? ;               
137    filterParameterList         ->  ( filterParameter (COMMA filterParameter)* ) ? ;
138    filterParameter             ->  (filterParameterMode COLON)? type identifier ;
139    filterParameterMode         ->  (IN | OUT | INOUT) ; // KH: not implemented
140
141    //
142    // 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
143    //   
144    graphDef                    ->  GRAPH identifier LROUND graphParameterList RROUND graphBody TERMINATOR ? ;
145   
146    graphParameterList          ->  ( graphParameter (COMMA graphParameter)* ) ? ; // KH: implement as a 'modal' parameter
147    graphParameter              ->  graphParameterMode? type identifier ;
148    graphParameterMode          ->  (IN | OUT | INOUT) ;
149   
150    graphBody                   ->  LCURLY graphVarDecls addFilterStmts RCURLY ;
151   
152    graphVarDecls               ->  ( structDecl | filterDecl ) * ; 
153    structDecl                  ->  structType identifier TERMINATOR ;
154    filterDecl                  ->  filterType identifier TERMINATOR ;
155   
156    // graphDecl                ->  GRAPH identifier TERMINATOR ;
157   
158    addFilterStmts              ->  addFilterStmt * ;
159    addFilterStmt                   ->  identifier LROUND addFilterArgList RROUND TERMINATOR ;
160    addFilterArgList            ->  (identifier (COMMA identifier) *) ? ;
161
162    //
163    // s t a t e m e n t s
164    //
165    stmt                        #->     varDecl | funcCallOrAssignStmt | returnStmt | ifStmt | whileStmt | foreachStmt | forStmt ;
166    blockStmt                   ->      LCURLY stmt* RCURLY ;
167    varDecl                     ->      type identifier (ASSIGN^ expr) ? TERMINATOR ;
168    funcCallOrAssignStmt        #->     expr (assignRest _promote_) ? TERMINATOR ; // KH: SA must validate 'expr' is a 'funcCall'
169    assignRest                  ->      assignOperator^! expr ;
170    assignOperator              ->      ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN |
171                                        MULTIPLY_ASSIGN | DIVIDE_ASSIGN | PLUS_ASSIGN | MINUS_ASSIGN ;       
172    returnStmt                  ->      RETURN (expr)? TERMINATOR ;
173    ifStmt                      ->      IF expr blockStmt (ELSE blockStmt)? ;                         
174    whileStmt                   ->      WHILE expr blockStmt ;
175
176    // KH: eliminate stream<1> type ? yes, for each not quite right
177    foreachStmt                 ->      FOREACH indexStreamDeclList IN targetStreamDeclList blockStmt ;
178    indexStreamDeclList         #->     streamDeclList ;
179    targetStreamDeclList        #->     streamDeclList ;
180    streamDeclList              ->      streamDecl ( COMMA streamDecl ) * ;
181    streamDecl                  ->      streamType identifier ;
182         
183         // KH: count controlled for loop to support reductions         
184    forStmt                     ->      FOR identifier IN stridedRange blockStmt ;
185           //indexTypeDecl             ->      indexType identifier ; // ?
186    stridedRange                ->      range step ;
187    range                       ->      integerConstant DDOT integerConstant ;
188    step                        #->     (BY integerConstant) | epsilon {@value = 1;} ;
189
190    //annotationStmt    -> AMPERSAND identifier LROUND annotationArgList RROUND blockStmt TERMINATOR ;
191    //annotationArgList -> (expr (COMMA expr)*) ?   
192
193    //
194    // e x p r e s s i o n s
195    //   
196   
197    // follows C++ operator precedence, DNE IN operator since list types DNE
198
199//    expr        #-> expr1 ((BY^) expr1)?                  _leftAssoc_ ;   
200//    expr1       #-> expr2 ((RANGE^) expr2)?               _leftAssoc_ ;
201    expr        #-> expr1 ((OR^) expr)?                   _leftAssoc_ ;
202    expr1       #-> expr2 ((XOR^) expr1)?                 _leftAssoc_ ;
203    expr2       #-> expr3 ((AND^) expr2)?                 _leftAssoc_ ;
204    expr3       #-> expr4 ((PLUS^ | MINUS^) expr3)?       _leftAssoc_ ;
205    expr4       #-> expr5 ((MULTIPLY^ | DIVIDE^) expr4)?  _leftAssoc_ ;
206    expr5       #-> ((PLUS^^ | MINUS^^)? expr6) | ((NOT^^)* expr6)                          ;
207    expr6       #-> compoundIdentifier ((funcCallRest _promote_) | (idisaFuncCallRest _promote_)) ? 
208                |   LROUND expr RROUND
209                |   constant ;
210
211    constant                #-> stringConstant | integerConstant ;
212    integerConstant         ->  INTEGER_CONST {@value = @@value;} ;
213    stringConstant          ->  STRING | SQ_STRING ;   
214    compoundIdentifier      #-> identifier (DOT^ identifier)?;
215    identifier              ->  IDENTIFIER ;
216    funcCallRest            ->  LROUND^ funcCallArgList RROUND ;
217    funcCallArgList         ->  (expr (COMMA expr)*) ? ;     
218    idisaFuncCallRest       ->  LANGLE^ fieldWidth RANGLE LROUND idisaFuncCallArgList RROUND ;
219    idisaFuncCallArgList    ->  (expr (COMMA expr)*) ? ;
220    fieldWidth              ->  integerConstant ;
221
222    //
223    // t y p e s
224    //
225    type                    #->     primitiveType   |
226                                    streamType      |
227                                    structType      |
228                                    filterType      ;
229
230    intType                 ->      INT    { @type = {{PrimitiveType.INTEGER}};  } ;
231    primitiveType           #->     intType ;
232    indexType               #->     intType ;
233   
234    streamType              ->      STREAM fieldWidthSpecifier! {   @fieldWidth = @:value;
235                                                                    @type = {{ StreamType.STREAM(%?) }} , @fieldWidth ;
236                                                                } ;
237    fieldWidthSpecifier     #->     (LANGLE integerConstant RANGLE ) | (epsilon {@value = 1;}) ;   
238    // fieldWidthSpecifier  #->     (LANGLE expr RANGLE ) | (epsilon {@value = 1;}) ;
239   
240    structType              ->      STRUCT identifier ;       
241    filterType              ->      FILTER identifier ;       
242}
Note: See TracBrowser for help on using the repository browser.