source: proto/pabloj/branches/refactor-experimental/input/grammar/scatter/pabloS.scatter @ 3166

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

Minor grammar updates to handle terminators correctly. Updates to sample test files. Minor updates to temp pabloS type system classes.

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