source: proto/pabloj/trunk/input/grammar/scatter/pabloS.scatter @ 3681

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

Minor changes.

File size: 6.7 KB
Line 
1//
2// Tom Shermer, Ken Herdy
3//
4// s2k - A domain specific language for streaming text extraction and transformations.
5//
6// Modified:            2012/09/08 Original definition.
7//                                             
8
9types {
10        toolchain.pabloS.lang.signatures.FunctionSignature,
11        toolchain.pabloS.lang.type.Type,
12        toolchain.pabloS.lang.type.PrimitiveType,
13        toolchain.pabloS.lang.type.StreamType,
14        toolchain.pabloS.semanticAnalyzer.Binding,
15        toolchain.pabloS.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        FUNCTION,       
36        STREAM,
37        STRUCT,
38        VOID,
39        INT,
40        IF,
41        ELSE,
42        WHILE,
43        RETURN,
44        AND             "&",
45        OR              "|",
46        NOT             "~",
47        XOR             "^",
48        MULTIPLY        "*",
49        DIVIDE          "/",
50        ADD                     "+",
51        SUBTRACT        "-",
52        ASSIGN      "=",
53        AND_ASSIGN  "&=",
54        OR_ASSIGN   "|=",
55        XOR_ASSIGN  "^=",
56        MULTIPLY_ASSIGN         "*=",
57        DIVIDE_ASSIGN           "/=",
58        ADD_ASSIGN                      "+=",
59        SUBTRACT_ASSIGN         "-=",
60        LANGLE          "<",
61        RANGLE          ">",
62        LCURLY          "{",
63        RCURLY          "}",
64        LROUND          "(",
65        RROUND          ")",
66        COMMA           ",",
67        TERMINATOR  ";",
68        DOT                     ".",
69  }
70}
71
72interfaces {
73         intValued {int value = 0;},
74         hasSymbolTable {SymbolTable symbolTable = null;},
75         hasBinding     {Binding binding = null;},
76         hasFieldWidth  {int fieldWidth = 1;},
77         hasSignature   {FunctionSignature signature = null;},
78}
79
80nodes {
81  ASTNode    {Type type = null;}  [assignOperator],
82  program    {hasSymbolTable;} [],
83  structDecl {hasSymbolTable;} [],
84  funcDef    {hasSymbolTable;} [],
85 
86  blockStmt  {hasSymbolTable;} [],             
87 
88  identifier         {hasBinding;} [],
89  compoundIdentifier {hasBinding;} [],
90 
91  binaryOperator {hasSignature;} [expr expr1 expr3 expr4],
92  unaryOperator  {hasSignature;} [expr2],       
93  funcCall       {hasSignature;} [funcCallRest],
94
95// parameterizedFuncCall {hasSignature;} [idisaFuncCallRest],
96
97  assign         {} [assignRest],
98 
99  streamType      {hasFieldWidth;} [],
100  integerConstant {intValued;}    [fieldWidthSpecifier],
101 
102  // primitiveType{} [intType voidType], // TODO - update S2B to handle this
103}
104
105grammar {
106
107        program         -> (structDecl | funcDef) *;    // ( 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        structDecl                        ->  STRUCT structName structDeclBody TERMINATOR? ;
113        structDeclBody          ->      LCURLY (structMember TERMINATOR)+ RCURLY ;
114        structMember              ->    structMemberType structMemberName ;
115        structMemberType        #-> streamType ;
116        structMemberName        #-> identifier ;
117   
118  //
119        // 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
120        //
121        funcDef                     -> FUNCTION returnType funcName LROUND parameterList? RROUND blockStmt TERMINATOR? ;                               
122        returnType                #-> type ;   
123        parameterList     -> parameter (COMMA parameter)*;
124        funcName                    #-> identifier ;
125        parameter                   -> type parameterName ;
126        parameterName     #-> identifier ;
127
128  //
129        // 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
130        //
131
132        //filterDef                             -> FILTER filterName LROUND filterParameterList? RROUND blockStmt TERMINATOR? ;                         
133        //filterName              #-> identifier ;
134        //filterParameterList     ->  parameter (COMMA parameter)*;
135        //filterParameter             ->  filterParameterMode? type filterParameterName ;
136  //filterParameterMode   -> (IN | OUT | INOUT) ;
137        //fillterParameterName  #-> 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 ; // add SA to validate expr is a function call
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 | voidType ) ;
198        intType                           ->            INT    { @type = {{PrimitiveType.INTEGER}};  } ;
199        voidType                          ->            VOID   { @type = {{PrimitiveType.VOID}}; } ;
200
201        streamType                      ->              STREAM fieldWidthSpecifier! {   @fieldWidth = @:value;
202                                                                                                                                @type = {{ StreamType.STREAM(%?) }} , @fieldWidth ;
203                                                                                                                } ;
204                                       
205        fieldWidthSpecifier     #->     (LANGLE integerConstant RANGLE ) | (epsilon {@value = 1;}) ;   
206        structType                      ->              STRUCT structName ;             
207        structName                      #->     identifier ;                           
208
209  //   
210        // s t r e a m   g r a p h
211        //
212
213  // graph              ->  LCURLY filterCall* RCURLY TERMINATOR ? ;  // add varDecl* first impl
214  // filterCall         ->  filterName LROUND RROUND TERMINATOR ;
215  // filterCallArgList  ->  (expr (COMMA expr)*) ? ; 
216
217 
218
219  //graph {
220  //  doProcess(fread("fin"), fwrite("out));
221  //} 
222
223 
224
225}
Note: See TracBrowser for help on using the repository browser.