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

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

Renamed structDecl to structDef

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