source: proto/pabloj/trunk/input/grammar/scatter/s2k.scatter @ 3699

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

Updated PabloJ to s2k.

File size: 8.3 KB
Line 
1// s2k - A domain specific language for streaming text extraction and transformations.
2//
3// Modified:    2012/09/08      Original definition.
4//
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        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    blockStmt               {hasSymbolTable;} [],
86    identifier              {hasBinding;} [],
87    compoundIdentifier      {hasBinding;} [],
88    binaryOperator          {hasSignature;} [expr expr1 expr3 expr4],
89    unaryOperator           {hasSignature;} [expr2],
90    funcCall                {hasSignature;} [funcCallRest],
91//  parameterizedFuncCall   {hasSignature;} [idisaFuncCallRest],
92    assign                  {} [assignRest],
93    streamType              {hasFieldWidth;} [],
94    integerConstant         {intValued;}    [fieldWidthSpecifier],
95//  primitiveType           {} [intType voidType], // TODO - update S2K2B2k to handle this
96}
97
98grammar {
99
100    program     -> (structDecl | funcDef) *;    // ( filterDef )* graph;
101
102    //
103    // s t r e a m   s t r u c t   d e f i n i t i o n s
104    //
105    structDecl          ->  STRUCT structName structDeclBody TERMINATOR? ;
106    structDeclBody      ->  LCURLY (structMember TERMINATOR)+ RCURLY ;
107    structMember        ->  structMemberType structMemberName ;
108    structMemberType    #-> streamType ;
109    structMemberName    #-> identifier ;
110
111    //
112    // 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
113    //
114    funcDef             ->  FUNCTION returnType funcName LROUND parameterList? RROUND blockStmt TERMINATOR? ;               
115    returnType          #-> type ;     
116    parameterList       ->  parameter (COMMA parameter)*;
117    funcName            #-> identifier ;
118    parameter           ->  type parameterName ;
119    parameterName       #-> identifier ;
120
121    //
122    // 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
123    //
124
125    //filterDef             -> FILTER filterName LROUND filterParameterList? RROUND blockStmt TERMINATOR? ;               
126    //filterName            #-> identifier ;
127    //filterParameterList   ->  parameter (COMMA parameter)*;
128    //filterParameter       ->  filterParameterMode? type filterParameterName ;
129    //filterParameterMode   -> (IN | OUT | INOUT) ;
130    //fillterParameterName  #-> identifier ;
131
132    //
133    // s t a t e m e n t s
134    //
135    stmt                        #->     varDecl | funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt  ;
136    blockStmt                   ->      LCURLY stmt* RCURLY ;
137    varDecl                     ->      type varName (ASSIGN^ expr) ? TERMINATOR ;
138    varName                     #->     identifier ; 
139    funcCallOrAssignStmt        #->     expr (assignRest _promote_) ? TERMINATOR ; // add SA to validate expr is a function call
140    assignRest                  ->      assignOperator^! expr ;
141    assignOperator              ->      ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN |
142                                        MULTIPLY_ASSIGN | DIVIDE_ASSIGN | ADD_ASSIGN | SUBTRACT_ASSIGN ;       
143    ifStmt                      ->      IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                         
144    whileStmt                   ->      WHILE LROUND expr RROUND blockStmt ;
145    returnStmt                  ->      RETURN (expr)? TERMINATOR ;
146
147  //forStmt       -> FOR LROUND elementName IN expr RROUND blockStmt ; // expr?
148  //elementName   #-> identifier ;
149
150  //annotationStmt    -> AMPERSAND annotationName LROUND annotationArgList RROUND blockStmt TERMINATOR ;
151  //annotationArgList -> (expr (COMMA expr)*) ?   
152
153    //
154    // e x p r e s s i o n s
155    //   
156    expr        #->    expr1 ((OR^|XOR^) expr)? _leftAssoc_ ;
157    expr1       #-> expr2 ((AND^) expr1)? _leftAssoc_ ;
158    expr2       #-> NOT^^? expr3;                                         
159    expr3       #-> expr4 ((MULTIPLY^ | DIVIDE^) expr3)? _leftAssoc_ ;
160    expr4       #-> expr5 ((ADD^ | SUBTRACT^) expr4)? _leftAssoc_ ;
161    expr5       #-> LROUND expr RROUND
162                | constant
163                | compoundIdentifier (funcCallRest _promote_) ? ; // | compoundIdentifier ((funcCallRest _promote_) | (parameterizedFuncCallRest _promote_)) ? ;
164
165// fieldWidthSpecifier
166
167//    parameterizedFuncCallRest         ->      LANGLE fieldWidth RANGLE LROUND idisaFuncCallArgList RROUND;
168//    fieldWidth                        #->     (LANGLE integer RANGLE ) ;   
169                                                                                                                                   
170    constant                #-> stringConstant | integerConstant ;
171    integerConstant         ->     INTEGER_CONST {@value = @@value;} ;
172    stringConstant          ->     STRING | SQ_STRING ;   
173    compoundIdentifier      #-> identifier (DOT^ identifier)?;
174    identifier              ->     IDENTIFIER ;
175    funcCallRest            ->     LROUND^ funcCallArgList RROUND ;
176    funcCallArgList         ->     (expr (COMMA expr)*) ? ;     
177
178// TODO - idisa function call simd.popcount<>(); -> simd.popcount<128>() + ... + simd.popcount<128>()
179//
180//        package.name - if 'esimd' then ...
181//
182
183    //
184    // t y p e s
185    //
186    type                    #->     primitiveType   |
187                                    streamType      |
188                                    structType;
189
190    primitiveType           #->     ( intType | voidType ) ;
191    intType                 ->      INT    { @type = {{PrimitiveType.INTEGER}};  } ;
192    voidType                ->      VOID   { @type = {{PrimitiveType.VOID}}; } ;
193
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.