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

Last change on this file since 3365 was 3365, checked in by ksherdy, 6 years ago

SVN blues, incremental commits.

File size: 5.2 KB
Line 
1//
2// Tom Shermer, Ken Herdy
3//
4// PabloS - Parallel Stream Language 
5//
6// A tiny language for the definition of stream structures and stream functions.
7//
8// Modified:            2012/09/08 Original definition.
9//                                             
10
11types {
12        toolchain.pabloS.lang.signatures.FunctionSignature,
13        toolchain.pabloS.lang.type.Type,
14        toolchain.pabloS.lang.type.PrimitiveType,
15        toolchain.pabloS.lang.type.StreamType,
16        toolchain.pabloS.semanticAnalyzer.Binding,
17        toolchain.pabloS.semanticAnalyzer.SymbolTable,
18}
19
20context main {
21
22  recognizers {
23         Whitespace [IGNORE],
24         Integer [INTEGER_CONST],
25         Identifier [IDENTIFIER],                       // Java identifiers, except $ character. Produces Lextant tokens for keywords.
26         Comment [IGNORE] "#" "\n",                     // Support parabix2_pablo debugging.
27         Comment [IGNORE] "//" "\n",     
28         Comment [SQ_STRING] "'" "'",
29         Comment [IGNORE] "/*" "*/",            // Comment. Comment [STRING] "/*" "*/",
30         String [STRING],
31         Punctuator,
32         EndOfInput,
33  }
34
35  // t o k e n s
36  tokens {
37        FUNCTION,       
38        STREAM,
39        STRUCT,
40        VOID,
41        INT,
42        IF,
43        ELSE,
44        WHILE,
45        RETURN,
46        AND             "&",
47        OR              "|",
48        NOT             "~",
49        XOR             "^",
50        MULTIPLY        "*",
51        DIVIDE          "/",
52        ADD                     "+",
53        SUBTRACT        "-",
54        ASSIGN      "=",
55        AND_ASSIGN  "&=",
56        OR_ASSIGN   "|=",
57        XOR_ASSIGN  "^=",
58        MULTIPLY_ASSIGN         "*=",
59        DIVIDE_ASSIGN           "/=",
60        ADD_ASSIGN                      "+=",
61        SUBTRACT_ASSIGN         "-=",
62        LANGLE          "<",
63        RANGLE          ">",
64        LCURLY          "{",
65        RCURLY          "}",
66        LROUND          "(",
67        RROUND          ")",
68        COMMA           ",",
69        TERMINATOR  ";",
70        DOT                     ".",
71  }
72}
73
74interfaces {
75         intValued {int value = 0;},
76         hasSymbolTable {SymbolTable symbolTable = null;},
77         hasBinding     {Binding binding = null;},
78         hasFieldWidth  {int fieldWidth = 1;},
79         hasSignature   {FunctionSignature signature = null;},
80}
81
82nodes {
83  ASTNode    {Type type = null;}  [assignOperator],
84  program    {hasSymbolTable;} [],
85  structDecl {hasSymbolTable;} [],
86  funcDef    {hasSymbolTable;} [],
87 
88  blockStmt  {hasSymbolTable;} [],             
89 
90  identifier         {hasBinding;} [],
91  compoundIdentifier {hasBinding;} [],
92 
93  binaryOperator {hasSignature;} [expr expr1 expr3 expr4],
94  unaryOperator  {hasSignature;} [expr2],       
95  funcCall       {hasSignature;} [funcCallRest],
96  assign         {} [assignRest],
97 
98  streamType      {hasFieldWidth;} [],
99  integerConstant {intValued;}    [fieldWidthSpecifier],
100 
101  // primitiveType{} [intType voidType], // TODO - update S2B to handle this
102}
103
104grammar {
105
106        program         -> (structDecl | funcDef) *;                   
107
108        //
109        // s t r e a m   s t r u c t   d e c l a r a t i o n s 
110        //
111        structDecl                      ->  STRUCT structName structDeclBody TERMINATOR? ;
112        structDeclBody          ->      LCURLY (structMember TERMINATOR)+ RCURLY ;
113        structMember            ->      structMemberType structMemberName ;
114        structMemberType        #-> structType | streamType ;
115        structMemberName        #-> identifier ;
116   
117    //
118        // s t r e a m   f u n c t i o n   d e c l a r a t i o n s                                                     
119        //
120        funcDef                 -> FUNCTION returnType funcName LROUND parameterList? RROUND blockStmt TERMINATOR? ;                           
121        returnType              #-> type ;     
122        parameterList   -> parameter (COMMA parameter)*;
123        funcName                #-> identifier ;
124        parameter               -> type parameterName ;
125        parameterName   #-> identifier ;
126               
127        //
128        // s t a t e m e n t s
129        //
130        stmt                                    #->     varDecl | funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt  ;
131        blockStmt                               ->      LCURLY stmt* RCURLY ;
132        varDecl                                 ->      type varName (ASSIGN^ expr) ? TERMINATOR ;
133        varName                                 #-> identifier ; 
134        funcCallOrAssignStmt    #-> expr (assignRest _promote_) ? TERMINATOR ; // add SA to validate expr is a function call
135        assignRest                              ->      assignOperator^! expr ;
136        assignOperator                  ->      ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN |
137                                                                MULTIPLY_ASSIGN | DIVIDE_ASSIGN | ADD_ASSIGN | SUBTRACT_ASSIGN ;               
138        ifStmt                                  ->  IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                                                 
139        whileStmt                               ->      WHILE LROUND expr RROUND blockStmt ;
140        returnStmt                              ->      RETURN (expr)? TERMINATOR ;
141
142        //
143        // e x p r e s s i o n s
144        //     
145        expr    #->     expr1 ((OR^|XOR^) expr)? _leftAssoc_ ;
146        expr1   #-> expr2 ((AND^) expr1)? _leftAssoc_ ;
147        expr2   #-> NOT^^* expr3;                                                                               // TODO - KH: verify '*' on 'NOT'
148        expr3   #-> expr4 ((MULTIPLY^ | DIVIDE^) expr3)? _leftAssoc_ ;
149        expr4   #-> expr5 ((ADD^ | SUBTRACT^) expr4)? _leftAssoc_ ;
150        expr5   #-> LROUND expr RROUND
151                                        | constant
152                                        | compoundIdentifier (funcCallRest _promote_) ?
153                                        ;
154                                                                                                                                                                                                                                                                       
155        constant                                #-> stringConstant | integerConstant ;
156        integerConstant                 ->      INTEGER_CONST {@value = @@value;} ;
157        stringConstant                  ->      STRING | SQ_STRING ;   
158        compoundIdentifier              #-> identifier (DOT^ identifier)?;
159        identifier                              ->      IDENTIFIER ;
160    funcCallRest                        ->      LROUND^ funcCallArgList RROUND ;
161        funcCallArgList                 ->      (expr (COMMA expr)*) ? ;       
162               
163    //   
164        // t y p e s
165        //
166        type                            #->     primitiveType   |
167                                                                streamType              |
168                                                                structType              ;
169
170        primitiveType           #->     ( intType | voidType ) ;
171        intType                         ->              INT    { @type = {{PrimitiveType.INTEGER}};  } ;
172        voidType                        ->              VOID   { @type = {{PrimitiveType.VOID}}; } ;
173
174        streamType                      ->              STREAM fieldWidthSpecifier! {   @fieldWidth = @:value;
175                                                                                                                                @type = {{ StreamType.STREAM(%?) }} , @fieldWidth ;
176                                                                                                                } ;
177                                       
178        fieldWidthSpecifier     #->     (LANGLE integerConstant RANGLE ) | (epsilon {@value = 1;}) ;   
179        structType                      ->              STRUCT structName ;             
180        structName                      #->     identifier ;                           
181
182}
Note: See TracBrowser for help on using the repository browser.