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

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

Replaced function keyword with filter.

File size: 8.2 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        STREAM,
37        STRUCT,
38        INT,
39        IF,
40        ELSE,
41        WHILE,
42        RETURN,
43        AND             "&",
44        OR              "|",
45        NOT             "~",
46        XOR             "^",
47        MULTIPLY        "*",
48        DIVIDE          "/",
49        ADD             "+",
50        SUBTRACT        "-",
51        ASSIGN          "=",
52        AND_ASSIGN      "&=",
53        OR_ASSIGN       "|=",
54        XOR_ASSIGN      "^=",
55        MULTIPLY_ASSIGN "*=",
56        DIVIDE_ASSIGN   "/=",
57        ADD_ASSIGN      "+=",
58        SUBTRACT_ASSIGN "-=",
59        LANGLE          "<",
60        RANGLE          ">",
61        LCURLY          "{",
62        RCURLY          "}",
63        LROUND          "(",
64        RROUND          ")",
65        COMMA           ",",
66        TERMINATOR      ";",
67        DOT             ".",
68    }
69}
70
71interfaces {
72    intValued       {int value = 0;},
73    hasSymbolTable  {SymbolTable symbolTable = null;},
74    hasBinding      {Binding binding = null;},
75    hasFieldWidth   {int fieldWidth = 1;},
76    hasSignature    {FunctionSignature signature = null;},
77}
78
79nodes {
80    ASTNode                 {Type type = null;}  [assignOperator],
81    program                 {hasSymbolTable;} [],
82    structDecl              {hasSymbolTable;} [],
83    funcDef                 {hasSymbolTable;} [],
84    blockStmt               {hasSymbolTable;} [],
85    identifier              {hasBinding;} [],
86    compoundIdentifier      {hasBinding;} [],
87    binaryOperator          {hasSignature;} [expr expr1 expr3 expr4],
88    unaryOperator           {hasSignature;} [expr2],
89    funcCall                {hasSignature;} [funcCallRest],
90//  parameterizedFuncCall   {hasSignature;} [idisaFuncCallRest],
91    assign                  {} [assignRest],
92    streamType              {hasFieldWidth;} [],
93    integerConstant         {intValued;}    [fieldWidthSpecifier],
94//  primitiveType           {} [intType voidType], // TODO - update S2K2B2k to handle primitiveType
95}
96
97grammar {
98
99    program     -> (structDecl | funcDef) *;    // ( filterDef )* graph;
100
101    //
102    // s t r e a m   s t r u c t   d e f i n i t i o n s
103    //
104    structDecl          ->  STRUCT structName structDeclBody TERMINATOR? ;
105    structDeclBody      ->  LCURLY (structMember TERMINATOR)+ RCURLY ;
106    structMember        ->  structMemberType structMemberName ;
107    structMemberType    #-> streamType ;
108    structMemberName    #-> identifier ;
109
110    //
111    // 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
112    //
113    funcDef             ->  FILTER funcName LROUND parameterList? RROUND blockStmt TERMINATOR? ;                     
114    parameterList       ->  parameter (COMMA parameter)*;
115    funcName            #-> identifier ;
116    parameter           ->  type parameterName ;
117    parameterName       #-> identifier ;
118
119    //
120    // 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
121    //
122
123    //filterDef             -> FILTER filterName LROUND filterParameterList? RROUND blockStmt TERMINATOR? ;               
124    //filterName            #-> identifier ;
125    //filterParameterList   ->  parameter (COMMA parameter)*;
126    //filterParameter       ->  filterParameterMode? type filterParameterName ;
127    //filterParameterMode   -> (IN | OUT | INOUT) ;
128    //fillterParameterName  #-> identifier ;
129
130    //
131    // s t a t e m e n t s
132    //
133    stmt                        #->     varDecl | funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt  ;
134    blockStmt                   ->      LCURLY stmt* RCURLY ;
135    varDecl                     ->      type varName (ASSIGN^ expr) ? TERMINATOR ;
136    varName                     #->     identifier ; 
137    funcCallOrAssignStmt        #->     expr (assignRest _promote_) ? TERMINATOR ; // add SA to validate expr is a function call
138    assignRest                  ->      assignOperator^! expr ;
139    assignOperator              ->      ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN |
140                                        MULTIPLY_ASSIGN | DIVIDE_ASSIGN | ADD_ASSIGN | SUBTRACT_ASSIGN ;       
141    ifStmt                      ->      IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                         
142    whileStmt                   ->      WHILE LROUND expr RROUND blockStmt ;
143    returnStmt                  ->      RETURN (expr)? TERMINATOR ;
144
145  //forStmt       -> FOR LROUND elementName IN expr RROUND blockStmt ; // expr?
146  //elementName   #-> identifier ;
147
148  //annotationStmt    -> AMPERSAND annotationName LROUND annotationArgList RROUND blockStmt TERMINATOR ;
149  //annotationArgList -> (expr (COMMA expr)*) ?   
150
151    //
152    // e x p r e s s i o n s
153    //   
154    expr        #-> expr1 ((OR^|XOR^) expr)? _leftAssoc_ ;
155    expr1       #-> expr2 ((AND^) expr1)? _leftAssoc_ ;
156    expr2       #-> NOT^^? expr3;                                         
157    expr3       #-> expr4 ((MULTIPLY^ | DIVIDE^) expr3)? _leftAssoc_ ;
158    expr4       #-> expr5 ((ADD^ | SUBTRACT^) expr4)? _leftAssoc_ ;
159    expr5       #-> LROUND expr RROUND
160                | constant
161                | compoundIdentifier (funcCallRest _promote_) ? ; // | compoundIdentifier ((funcCallRest _promote_) | (parameterizedFuncCallRest _promote_)) ? ;
162
163// fieldWidthSpecifier
164
165//    parameterizedFuncCallRest         ->      LANGLE fieldWidth RANGLE LROUND idisaFuncCallArgList RROUND;
166//    fieldWidth                        #->     (LANGLE integer RANGLE ) ;   
167                                                                                                                                   
168    constant                #-> stringConstant | integerConstant ;
169    integerConstant         ->     INTEGER_CONST {@value = @@value;} ;
170    stringConstant          ->     STRING | SQ_STRING ;   
171    compoundIdentifier      #-> identifier (DOT^ identifier)?;
172    identifier              ->     IDENTIFIER ;
173    funcCallRest            ->     LROUND^ funcCallArgList RROUND ;
174    funcCallArgList         ->     (expr (COMMA expr)*) ? ;     
175
176// TODO - idisa function call simd.popcount<>(); -> simd.popcount<128>() + ... + simd.popcount<128>()
177//
178//        package.name - if 'esimd' then ...
179//
180
181    //
182    // t y p e s
183    //
184    type                    #->     primitiveType   |
185                                    streamType      |
186                                    structType;
187
188    primitiveType           #->     ( intType ) ;
189    intType                 ->      INT    { @type = {{PrimitiveType.INTEGER}};  } ;
190    streamType              ->      STREAM fieldWidthSpecifier! {   @fieldWidth = @:value;
191                                                                    @type = {{ StreamType.STREAM(%?) }} , @fieldWidth ;
192                                                                } ;
193                   
194    fieldWidthSpecifier     #->      (LANGLE integerConstant RANGLE ) | (epsilon {@value = 1;}) ;   
195    structType              ->       STRUCT structName ;       
196    structName              #->      identifier ;               
197
198    //
199    // s t r e a m   g r a p h
200    //
201
202    // graph              ->  LCURLY filterCall* RCURLY TERMINATOR ? ;  // add varDecl* first impl
203    // filterCall         ->  filterName LROUND RROUND TERMINATOR ;
204    // filterCallArgList  ->  (expr (COMMA expr)*) ? ; 
205
206    //graph {
207    //  doProcess(fread("fin"), fwrite("out));
208    //} 
209
210}
Note: See TracBrowser for help on using the repository browser.