parser.py (11282:afdcebd314be) parser.py (11283:4cc8b312f026)
1# Copyright (c) 2009 The Hewlett-Packard Development Company
2# All rights reserved.
3#
4# Redistribution and use in source and binary forms, with or without
5# modification, are permitted provided that the following conditions are
6# met: redistributions of source code must retain the above copyright
7# notice, this list of conditions and the following disclaimer;
8# redistributions in binary form must reproduce the above copyright
9# notice, this list of conditions and the following disclaimer in the
10# documentation and/or other materials provided with the distribution;
11# neither the name of the copyright holders nor the names of its
12# contributors may be used to endorse or promote products derived from
13# this software without specific prior written permission.
14#
15# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
19# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
21# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26#
27# Authors: Nathan Binkert
28
29import os.path
30import re
31import sys
32
33from m5.util import code_formatter
34from m5.util.grammar import Grammar, ParseError
35
36import slicc.ast as ast
37import slicc.util as util
38from slicc.symbols import SymbolTable
39
40class SLICC(Grammar):
41 def __init__(self, filename, base_dir, verbose=False, traceback=False, **kwargs):
42 self.protocol = None
43 self.traceback = traceback
44 self.verbose = verbose
45 self.symtab = SymbolTable(self)
46 self.base_dir = base_dir
47
48 try:
49 self.decl_list = self.parse_file(filename, **kwargs)
50 except ParseError, e:
51 if not self.traceback:
52 sys.exit(str(e))
53 raise
54
55 def currentLocation(self):
56 return util.Location(self.current_source, self.current_line,
57 no_warning=not self.verbose)
58
59 def codeFormatter(self, *args, **kwargs):
60 code = code_formatter(*args, **kwargs)
61 code['protocol'] = self.protocol
62 return code
63
64 def process(self):
1# Copyright (c) 2009 The Hewlett-Packard Development Company
2# All rights reserved.
3#
4# Redistribution and use in source and binary forms, with or without
5# modification, are permitted provided that the following conditions are
6# met: redistributions of source code must retain the above copyright
7# notice, this list of conditions and the following disclaimer;
8# redistributions in binary form must reproduce the above copyright
9# notice, this list of conditions and the following disclaimer in the
10# documentation and/or other materials provided with the distribution;
11# neither the name of the copyright holders nor the names of its
12# contributors may be used to endorse or promote products derived from
13# this software without specific prior written permission.
14#
15# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
19# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
21# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26#
27# Authors: Nathan Binkert
28
29import os.path
30import re
31import sys
32
33from m5.util import code_formatter
34from m5.util.grammar import Grammar, ParseError
35
36import slicc.ast as ast
37import slicc.util as util
38from slicc.symbols import SymbolTable
39
40class SLICC(Grammar):
41 def __init__(self, filename, base_dir, verbose=False, traceback=False, **kwargs):
42 self.protocol = None
43 self.traceback = traceback
44 self.verbose = verbose
45 self.symtab = SymbolTable(self)
46 self.base_dir = base_dir
47
48 try:
49 self.decl_list = self.parse_file(filename, **kwargs)
50 except ParseError, e:
51 if not self.traceback:
52 sys.exit(str(e))
53 raise
54
55 def currentLocation(self):
56 return util.Location(self.current_source, self.current_line,
57 no_warning=not self.verbose)
58
59 def codeFormatter(self, *args, **kwargs):
60 code = code_formatter(*args, **kwargs)
61 code['protocol'] = self.protocol
62 return code
63
64 def process(self):
65 self.decl_list.findMachines()
66 self.decl_list.generate()
67
68 def writeCodeFiles(self, code_path, includes):
69 self.symtab.writeCodeFiles(code_path, includes)
70
71 def writeHTMLFiles(self, html_path):
72 self.symtab.writeHTMLFiles(html_path)
73
74 def files(self):
65 self.decl_list.generate()
66
67 def writeCodeFiles(self, code_path, includes):
68 self.symtab.writeCodeFiles(code_path, includes)
69
70 def writeHTMLFiles(self, html_path):
71 self.symtab.writeHTMLFiles(html_path)
72
73 def files(self):
75 f = set([
76 'MachineType.cc',
77 'MachineType.hh',
78 'Types.hh' ])
74 f = set(['Types.hh'])
79
80 f |= self.decl_list.files()
81
82 return f
83
84 t_ignore = '\t '
85
86 # C or C++ comment (ignore)
87 def t_c_comment(self, t):
88 r'/\*(.|\n)*?\*/'
89 t.lexer.lineno += t.value.count('\n')
90
91 def t_cpp_comment(self, t):
92 r'//.*'
93
94 # Define a rule so we can track line numbers
95 def t_newline(self, t):
96 r'\n+'
97 t.lexer.lineno += len(t.value)
98
99 reserved = {
100 'protocol' : 'PROTOCOL',
101 'include' : 'INCLUDE',
102 'global' : 'GLOBAL',
103 'machine' : 'MACHINE',
104 'in_port' : 'IN_PORT',
105 'out_port' : 'OUT_PORT',
106 'action' : 'ACTION',
107 'transition' : 'TRANS',
108 'structure' : 'STRUCT',
109 'external_type' : 'EXTERN_TYPE',
110 'enumeration' : 'ENUM',
111 'state_declaration' : 'STATE_DECL',
112 'peek' : 'PEEK',
113 'stall_and_wait' : 'STALL_AND_WAIT',
114 'enqueue' : 'ENQUEUE',
115 'check_allocate' : 'CHECK_ALLOCATE',
116 'check_next_cycle' : 'CHECK_NEXT_CYCLE',
117 'check_stop_slots' : 'CHECK_STOP_SLOTS',
118 'static_cast' : 'STATIC_CAST',
119 'if' : 'IF',
120 'is_valid' : 'IS_VALID',
121 'is_invalid' : 'IS_INVALID',
122 'else' : 'ELSE',
123 'return' : 'RETURN',
124 'void' : 'VOID',
125 'new' : 'NEW',
126 'OOD' : 'OOD',
127 }
128
129 literals = ':[]{}(),='
130
131 tokens = [ 'EQ', 'NE', 'LT', 'GT', 'LE', 'GE',
132 'LEFTSHIFT', 'RIGHTSHIFT',
133 'NOT', 'AND', 'OR',
134 'PLUS', 'DASH', 'STAR', 'SLASH',
135 'INCR', 'DECR',
136 'DOUBLE_COLON', 'SEMI',
137 'ASSIGN', 'DOT',
138 'IDENT', 'LIT_BOOL', 'FLOATNUMBER', 'NUMBER', 'STRING' ]
139 tokens += reserved.values()
140
141 t_EQ = r'=='
142 t_NE = r'!='
143 t_LT = r'<'
144 t_GT = r'>'
145 t_LE = r'<='
146 t_GE = r'>='
147 t_LEFTSHIFT = r'<<'
148 t_RIGHTSHIFT = r'>>'
149 t_NOT = r'!'
150 t_AND = r'&&'
151 t_OR = r'\|\|'
152 t_PLUS = r'\+'
153 t_DASH = r'-'
154 t_STAR = r'\*'
155 t_SLASH = r'/'
156 t_DOUBLE_COLON = r'::'
157 t_SEMI = r';'
158 t_ASSIGN = r':='
159 t_DOT = r'\.'
160 t_INCR = r'\+\+'
161 t_DECR = r'--'
162
163 precedence = (
164 ('left', 'INCR', 'DECR'),
165 ('left', 'AND', 'OR'),
166 ('left', 'EQ', 'NE'),
167 ('left', 'LT', 'GT', 'LE', 'GE'),
168 ('left', 'RIGHTSHIFT', 'LEFTSHIFT'),
169 ('left', 'PLUS', 'DASH'),
170 ('left', 'STAR', 'SLASH'),
171 ('right', 'NOT', 'UMINUS'),
172 )
173
174 def t_IDENT(self, t):
175 r'[a-zA-Z_][a-zA-Z_0-9]*'
176 if t.value == 'true':
177 t.type = 'LIT_BOOL'
178 t.value = True
179 return t
180
181 if t.value == 'false':
182 t.type = 'LIT_BOOL'
183 t.value = False
184 return t
185
186 # Check for reserved words
187 t.type = self.reserved.get(t.value, 'IDENT')
188 return t
189
190 def t_FLOATNUMBER(self, t):
191 '[0-9]+[.][0-9]+'
192 try:
193 t.value = float(t.value)
194 except ValueError:
195 raise ParseError("Illegal float", t)
196 return t
197
198 def t_NUMBER(self, t):
199 r'[0-9]+'
200 try:
201 t.value = int(t.value)
202 except ValueError:
203 raise ParseError("Illegal number", t)
204 return t
205
206 def t_STRING1(self, t):
207 r'\"[^"\n]*\"'
208 t.type = 'STRING'
209 t.value = t.value[1:-1]
210 return t
211
212 def t_STRING2(self, t):
213 r"\'[^'\n]*\'"
214 t.type = 'STRING'
215 t.value = t.value[1:-1]
216 return t
217
218 def p_file(self, p):
219 "file : decls"
220 p[0] = p[1]
221
222 def p_empty(self, p):
223 "empty :"
224
225 def p_decls(self, p):
226 "decls : declsx"
227 p[0] = ast.DeclListAST(self, p[1])
228
229 def p_declsx__list(self, p):
230 "declsx : decl declsx"
231 if isinstance(p[1], ast.DeclListAST):
232 decls = p[1].decls
233 elif p[1] is None:
234 decls = []
235 else:
236 decls = [ p[1] ]
237 p[0] = decls + p[2]
238
239 def p_declsx__none(self, p):
240 "declsx : empty"
241 p[0] = []
242
243 def p_decl__protocol(self, p):
244 "decl : PROTOCOL STRING SEMI"
245 if self.protocol:
246 msg = "Protocol can only be set once! Error at %s:%s\n" % \
247 (self.current_source, self.current_line)
248 raise ParseError(msg)
249 self.protocol = p[2]
250 p[0] = None
251
252 def p_decl__include(self, p):
253 "decl : INCLUDE STRING SEMI"
254 dirname = os.path.dirname(self.current_source)
255 if os.path.exists(os.path.join(dirname, p[2])):
256 filename = os.path.join(dirname, p[2])
257 else:
258 filename = os.path.join(self.base_dir, p[2])
259 p[0] = self.parse_file(filename)
260
261 def p_decl__machine0(self, p):
75
76 f |= self.decl_list.files()
77
78 return f
79
80 t_ignore = '\t '
81
82 # C or C++ comment (ignore)
83 def t_c_comment(self, t):
84 r'/\*(.|\n)*?\*/'
85 t.lexer.lineno += t.value.count('\n')
86
87 def t_cpp_comment(self, t):
88 r'//.*'
89
90 # Define a rule so we can track line numbers
91 def t_newline(self, t):
92 r'\n+'
93 t.lexer.lineno += len(t.value)
94
95 reserved = {
96 'protocol' : 'PROTOCOL',
97 'include' : 'INCLUDE',
98 'global' : 'GLOBAL',
99 'machine' : 'MACHINE',
100 'in_port' : 'IN_PORT',
101 'out_port' : 'OUT_PORT',
102 'action' : 'ACTION',
103 'transition' : 'TRANS',
104 'structure' : 'STRUCT',
105 'external_type' : 'EXTERN_TYPE',
106 'enumeration' : 'ENUM',
107 'state_declaration' : 'STATE_DECL',
108 'peek' : 'PEEK',
109 'stall_and_wait' : 'STALL_AND_WAIT',
110 'enqueue' : 'ENQUEUE',
111 'check_allocate' : 'CHECK_ALLOCATE',
112 'check_next_cycle' : 'CHECK_NEXT_CYCLE',
113 'check_stop_slots' : 'CHECK_STOP_SLOTS',
114 'static_cast' : 'STATIC_CAST',
115 'if' : 'IF',
116 'is_valid' : 'IS_VALID',
117 'is_invalid' : 'IS_INVALID',
118 'else' : 'ELSE',
119 'return' : 'RETURN',
120 'void' : 'VOID',
121 'new' : 'NEW',
122 'OOD' : 'OOD',
123 }
124
125 literals = ':[]{}(),='
126
127 tokens = [ 'EQ', 'NE', 'LT', 'GT', 'LE', 'GE',
128 'LEFTSHIFT', 'RIGHTSHIFT',
129 'NOT', 'AND', 'OR',
130 'PLUS', 'DASH', 'STAR', 'SLASH',
131 'INCR', 'DECR',
132 'DOUBLE_COLON', 'SEMI',
133 'ASSIGN', 'DOT',
134 'IDENT', 'LIT_BOOL', 'FLOATNUMBER', 'NUMBER', 'STRING' ]
135 tokens += reserved.values()
136
137 t_EQ = r'=='
138 t_NE = r'!='
139 t_LT = r'<'
140 t_GT = r'>'
141 t_LE = r'<='
142 t_GE = r'>='
143 t_LEFTSHIFT = r'<<'
144 t_RIGHTSHIFT = r'>>'
145 t_NOT = r'!'
146 t_AND = r'&&'
147 t_OR = r'\|\|'
148 t_PLUS = r'\+'
149 t_DASH = r'-'
150 t_STAR = r'\*'
151 t_SLASH = r'/'
152 t_DOUBLE_COLON = r'::'
153 t_SEMI = r';'
154 t_ASSIGN = r':='
155 t_DOT = r'\.'
156 t_INCR = r'\+\+'
157 t_DECR = r'--'
158
159 precedence = (
160 ('left', 'INCR', 'DECR'),
161 ('left', 'AND', 'OR'),
162 ('left', 'EQ', 'NE'),
163 ('left', 'LT', 'GT', 'LE', 'GE'),
164 ('left', 'RIGHTSHIFT', 'LEFTSHIFT'),
165 ('left', 'PLUS', 'DASH'),
166 ('left', 'STAR', 'SLASH'),
167 ('right', 'NOT', 'UMINUS'),
168 )
169
170 def t_IDENT(self, t):
171 r'[a-zA-Z_][a-zA-Z_0-9]*'
172 if t.value == 'true':
173 t.type = 'LIT_BOOL'
174 t.value = True
175 return t
176
177 if t.value == 'false':
178 t.type = 'LIT_BOOL'
179 t.value = False
180 return t
181
182 # Check for reserved words
183 t.type = self.reserved.get(t.value, 'IDENT')
184 return t
185
186 def t_FLOATNUMBER(self, t):
187 '[0-9]+[.][0-9]+'
188 try:
189 t.value = float(t.value)
190 except ValueError:
191 raise ParseError("Illegal float", t)
192 return t
193
194 def t_NUMBER(self, t):
195 r'[0-9]+'
196 try:
197 t.value = int(t.value)
198 except ValueError:
199 raise ParseError("Illegal number", t)
200 return t
201
202 def t_STRING1(self, t):
203 r'\"[^"\n]*\"'
204 t.type = 'STRING'
205 t.value = t.value[1:-1]
206 return t
207
208 def t_STRING2(self, t):
209 r"\'[^'\n]*\'"
210 t.type = 'STRING'
211 t.value = t.value[1:-1]
212 return t
213
214 def p_file(self, p):
215 "file : decls"
216 p[0] = p[1]
217
218 def p_empty(self, p):
219 "empty :"
220
221 def p_decls(self, p):
222 "decls : declsx"
223 p[0] = ast.DeclListAST(self, p[1])
224
225 def p_declsx__list(self, p):
226 "declsx : decl declsx"
227 if isinstance(p[1], ast.DeclListAST):
228 decls = p[1].decls
229 elif p[1] is None:
230 decls = []
231 else:
232 decls = [ p[1] ]
233 p[0] = decls + p[2]
234
235 def p_declsx__none(self, p):
236 "declsx : empty"
237 p[0] = []
238
239 def p_decl__protocol(self, p):
240 "decl : PROTOCOL STRING SEMI"
241 if self.protocol:
242 msg = "Protocol can only be set once! Error at %s:%s\n" % \
243 (self.current_source, self.current_line)
244 raise ParseError(msg)
245 self.protocol = p[2]
246 p[0] = None
247
248 def p_decl__include(self, p):
249 "decl : INCLUDE STRING SEMI"
250 dirname = os.path.dirname(self.current_source)
251 if os.path.exists(os.path.join(dirname, p[2])):
252 filename = os.path.join(dirname, p[2])
253 else:
254 filename = os.path.join(self.base_dir, p[2])
255 p[0] = self.parse_file(filename)
256
257 def p_decl__machine0(self, p):
262 "decl : MACHINE '(' ident ')' ':' obj_decls '{' decls '}'"
258 "decl : MACHINE '(' enumeration ')' ':' obj_decls '{' decls '}'"
263 p[0] = ast.MachineAST(self, p[3], [], p[7], p[9])
264
265 def p_decl__machine1(self, p):
259 p[0] = ast.MachineAST(self, p[3], [], p[7], p[9])
260
261 def p_decl__machine1(self, p):
266 "decl : MACHINE '(' ident pairs ')' ':' obj_decls '{' decls '}'"
262 "decl : MACHINE '(' enumeration pairs ')' ':' obj_decls '{' decls '}'"
267 p[0] = ast.MachineAST(self, p[3], p[4], p[7], p[9])
268
269 def p_decl__action(self, p):
270 "decl : ACTION '(' ident pairs ')' statements"
271 p[0] = ast.ActionDeclAST(self, p[3], p[4], p[6])
272
273 def p_decl__in_port(self, p):
274 "decl : IN_PORT '(' ident ',' type ',' var pairs ')' statements"
275 p[0] = ast.InPortDeclAST(self, p[3], p[5], p[7], p[8], p[10])
276
277 def p_decl__out_port(self, p):
278 "decl : OUT_PORT '(' ident ',' type ',' var pairs ')' SEMI"
279 p[0] = ast.OutPortDeclAST(self, p[3], p[5], p[7], p[8])
280
281 def p_decl__trans0(self, p):
282 "decl : TRANS '(' idents ',' idents ',' ident_or_star ')' idents"
283 p[0] = ast.TransitionDeclAST(self, [], p[3], p[5], p[7], p[9])
284
285 def p_decl__trans1(self, p):
286 "decl : TRANS '(' idents ',' idents ')' idents"
287 p[0] = ast.TransitionDeclAST(self, [], p[3], p[5], None, p[7])
288
289 def p_decl__trans2(self, p):
290 "decl : TRANS '(' idents ',' idents ',' ident_or_star ')' idents idents"
291 p[0] = ast.TransitionDeclAST(self, p[9], p[3], p[5], p[7], p[10])
292
293 def p_decl__trans3(self, p):
294 "decl : TRANS '(' idents ',' idents ')' idents idents"
295 p[0] = ast.TransitionDeclAST(self, p[7], p[3], p[5], None, p[8])
296
297 def p_decl__extern0(self, p):
298 "decl : EXTERN_TYPE '(' type pairs ')' SEMI"
299 p[4]["external"] = "yes"
300 p[0] = ast.TypeDeclAST(self, p[3], p[4], [])
301
302 def p_decl__global(self, p):
303 "decl : GLOBAL '(' type pairs ')' '{' type_members '}'"
304 p[4]["global"] = "yes"
305 p[0] = ast.TypeDeclAST(self, p[3], p[4], p[7])
306
307 def p_decl__struct(self, p):
308 "decl : STRUCT '(' type pairs ')' '{' type_members '}'"
309 p[0] = ast.TypeDeclAST(self, p[3], p[4], p[7])
310
311 def p_decl__enum(self, p):
312 "decl : ENUM '(' type pairs ')' '{' type_enums '}'"
313 p[4]["enumeration"] = "yes"
314 p[0] = ast.EnumDeclAST(self, p[3], p[4], p[7])
315
316 def p_decl__state_decl(self, p):
317 "decl : STATE_DECL '(' type pairs ')' '{' type_states '}'"
318 p[4]["enumeration"] = "yes"
319 p[4]["state_decl"] = "yes"
320 p[0] = ast.StateDeclAST(self, p[3], p[4], p[7])
321
322 # Type fields
323 def p_obj_decls__list(self, p):
324 "obj_decls : obj_decl obj_decls"
325 p[0] = [ p[1] ] + p[2]
326
327 def p_obj_decls__empty(self, p):
328 "obj_decls : empty"
329 p[0] = []
330
331 def p_type_members__list(self, p):
332 "type_members : type_member type_members"
333 p[0] = [ p[1] ] + p[2]
334
335 def p_type_members__empty(self, p):
336 "type_members : empty"
337 p[0] = []
338
339 def p_type_member__0(self, p):
340 """type_member : obj_decl
341 | func_decl
342 | func_def"""
343 p[0] = p[1]
344
345 # Member / Variable declarations
346 def p_decl__obj_decl(self, p):
347 "decl : obj_decl"
348 p[0] = p[1]
349
350 def p_obj_decl__0(self, p):
351 "obj_decl : type ident pairs SEMI"
352 p[0] = ast.ObjDeclAST(self, p[1], p[2], p[3], None, False)
353
354 def p_obj_decl__1(self, p):
355 "obj_decl : type STAR ident pairs SEMI"
356 p[0] = ast.ObjDeclAST(self, p[1], p[3], p[4], None, True)
357
358 def p_obj_decl__2(self, p):
359 "obj_decl : type ident ASSIGN expr SEMI"
360 p[0] = ast.ObjDeclAST(self, p[1], p[2], ast.PairListAST(self), p[4],
361 False)
362
363 def p_obj_decl__3(self, p):
364 "obj_decl : type STAR ident ASSIGN expr SEMI"
365 p[0] = ast.ObjDeclAST(self, p[1], p[3], ast.PairListAST(self), p[5],
366 True)
367
368 # Function definition and declaration
369 def p_decl__func_decl(self, p):
370 "decl : func_decl"
371 p[0] = p[1]
372
373 def p_func_decl__0(self, p):
374 """func_decl : void ident '(' params ')' pairs SEMI
375 | type ident '(' params ')' pairs SEMI"""
376 p[0] = ast.FuncDeclAST(self, p[1], p[2], p[4], p[6], None)
377
378 def p_func_decl__1(self, p):
379 """func_decl : void ident '(' types ')' pairs SEMI
380 | type ident '(' types ')' pairs SEMI"""
381 p[0] = ast.FuncDeclAST(self, p[1], p[2], p[4], p[6], None)
382
383 def p_decl__func_def(self, p):
384 "decl : func_def"
385 p[0] = p[1]
386
387 def p_func_def__0(self, p):
388 """func_def : void ident '(' params ')' pairs statements
389 | type ident '(' params ')' pairs statements"""
390 p[0] = ast.FuncDeclAST(self, p[1], p[2], p[4], p[6], p[7])
391
392 # Enum fields
393 def p_type_enums__list(self, p):
394 "type_enums : type_enum type_enums"
395 p[0] = [ p[1] ] + p[2]
396
397 def p_type_enums__empty(self, p):
398 "type_enums : empty"
399 p[0] = []
400
401 def p_type_enum(self, p):
402 "type_enum : ident pairs SEMI"
403 p[0] = ast.TypeFieldEnumAST(self, p[1], p[2])
404
405 # States
406 def p_type_states__list(self, p):
407 "type_states : type_state type_states"
408 p[0] = [ p[1] ] + p[2]
409
410 def p_type_states__empty(self, p):
411 "type_states : empty"
412 p[0] = []
413
414 def p_type_state(self, p):
415 "type_state : ident ',' enumeration pairs SEMI"
416 p[0] = ast.TypeFieldStateAST(self, p[1], p[3], p[4])
417
418 # Formal Param
419 def p_params__many(self, p):
420 "params : param ',' params"
421 p[0] = [ p[1] ] + p[3]
422
423 def p_params__one(self, p):
424 "params : param"
425 p[0] = [ p[1] ]
426
427 def p_params__none(self, p):
428 "params : empty"
429 p[0] = []
430
431 def p_param(self, p):
432 "param : type ident"
433 p[0] = ast.FormalParamAST(self, p[1], p[2])
434
435 def p_param__pointer(self, p):
436 "param : type STAR ident"
437 p[0] = ast.FormalParamAST(self, p[1], p[3], None, True)
438
439 def p_param__pointer_default(self, p):
440 "param : type STAR ident ASSIGN STRING"
441 p[0] = ast.FormalParamAST(self, p[1], p[3], p[5], True)
442
443 def p_param__default_number(self, p):
444 "param : type ident ASSIGN NUMBER"
445 p[0] = ast.FormalParamAST(self, p[1], p[2], p[4])
446
447 def p_param__default_bool(self, p):
448 "param : type ident ASSIGN LIT_BOOL"
449 p[0] = ast.FormalParamAST(self, p[1], p[2], p[4])
450
451 def p_param__default_string(self, p):
452 "param : type ident ASSIGN STRING"
453 p[0] = ast.FormalParamAST(self, p[1], p[2], p[4])
454
455 # Type
456 def p_types__multiple(self, p):
457 "types : type ',' types"
458 p[0] = [ p[1] ] + p[3]
459
460 def p_types__one(self, p):
461 "types : type"
462 p[0] = [ p[1] ]
463
464 def p_types__empty(self, p):
465 "types : empty"
466 p[0] = []
467
468 def p_typestr__multi(self, p):
469 "typestr : typestr DOUBLE_COLON ident"
470 p[0] = '%s::%s' % (p[1], p[3])
471
472 def p_typestr__single(self, p):
473 "typestr : ident"
474 p[0] = p[1]
475
476 def p_type__one(self, p):
477 "type : typestr"
478 p[0] = ast.TypeAST(self, p[1])
479
480 def p_void(self, p):
481 "void : VOID"
482 p[0] = ast.TypeAST(self, p[1])
483
484 # Idents and lists
485 def p_idents__braced(self, p):
486 "idents : '{' identx '}'"
487 p[0] = p[2]
488
489 def p_idents__bare(self, p):
490 "idents : ident"
491 p[0] = [ p[1] ]
492
493 def p_identx__multiple_1(self, p):
494 """identx : ident SEMI identx
495 | ident ',' identx"""
496 p[0] = [ p[1] ] + p[3]
497
498 def p_identx__multiple_2(self, p):
499 "identx : ident identx"
500 p[0] = [ p[1] ] + p[2]
501
502 def p_identx__single(self, p):
503 "identx : empty"
504 p[0] = [ ]
505
506 def p_ident(self, p):
507 "ident : IDENT"
508 p[0] = p[1]
509
510 def p_ident_or_star(self, p):
511 """ident_or_star : ident
512 | STAR"""
513 p[0] = p[1]
514
515 # Pair and pair lists
516 def p_pairs__list(self, p):
517 "pairs : ',' pairsx"
518 p[0] = p[2]
519
520 def p_pairs__empty(self, p):
521 "pairs : empty"
522 p[0] = ast.PairListAST(self)
523
524 def p_pairsx__many(self, p):
525 "pairsx : pair ',' pairsx"
526 p[0] = p[3]
527 p[0].addPair(p[1])
528
529 def p_pairsx__one(self, p):
530 "pairsx : pair"
531 p[0] = ast.PairListAST(self)
532 p[0].addPair(p[1])
533
534 def p_pair__assign(self, p):
535 """pair : ident '=' STRING
536 | ident '=' ident
537 | ident '=' NUMBER"""
538 p[0] = ast.PairAST(self, p[1], p[3])
539
540 def p_pair__literal(self, p):
541 "pair : STRING"
542 p[0] = ast.PairAST(self, "short", p[1])
543
544 # Below are the rules for action descriptions
545 def p_statements__inner(self, p):
546 "statements : '{' statements_inner '}'"
547 p[0] = ast.StatementListAST(self, p[2])
548
549 def p_statements__none(self, p):
550 "statements : '{' '}'"
551 p[0] = ast.StatementListAST(self, [])
552
553 def p_statements_inner__many(self, p):
554 "statements_inner : statement statements_inner"
555 p[0] = [ p[1] ] + p[2]
556
557 def p_statements_inner__one(self, p):
558 "statements_inner : statement"
559 p[0] = [ p[1] ]
560
561 def p_exprs__multiple(self, p):
562 "exprs : expr ',' exprs"
563 p[0] = [ p[1] ] + p[3]
564
565 def p_exprs__one(self, p):
566 "exprs : expr"
567 p[0] = [ p[1] ]
568
569 def p_exprs__empty(self, p):
570 "exprs : empty"""
571 p[0] = []
572
573 def p_statement__expression(self, p):
574 "statement : expr SEMI"
575 p[0] = ast.ExprStatementAST(self, p[1])
576
577 def p_statement__assign(self, p):
578 "statement : expr ASSIGN expr SEMI"
579 p[0] = ast.AssignStatementAST(self, p[1], p[3])
580
581 def p_statement__enqueue(self, p):
582 "statement : ENQUEUE '(' var ',' type ')' statements"
583 p[0] = ast.EnqueueStatementAST(self, p[3], p[5], None, p[7])
584
585 def p_statement__enqueue_latency(self, p):
586 "statement : ENQUEUE '(' var ',' type ',' expr ')' statements"
587 p[0] = ast.EnqueueStatementAST(self, p[3], p[5], p[7], p[9])
588
589 def p_statement__stall_and_wait(self, p):
590 "statement : STALL_AND_WAIT '(' var ',' var ')' SEMI"
591 p[0] = ast.StallAndWaitStatementAST(self, p[3], p[5])
592
593 def p_statement__peek(self, p):
594 "statement : PEEK '(' var ',' type pairs ')' statements"
595 p[0] = ast.PeekStatementAST(self, p[3], p[5], p[6], p[8], "peek")
596
597 def p_statement__check_allocate(self, p):
598 "statement : CHECK_ALLOCATE '(' var ')' SEMI"
599 p[0] = ast.CheckAllocateStatementAST(self, p[3])
600
601 def p_statement__check_next_cycle(self, p):
602 "statement : CHECK_NEXT_CYCLE '(' ')' SEMI"
603 p[0] = ast.CheckNextCycleAST(self)
604
605 def p_statement__check_stop(self, p):
606 "statement : CHECK_STOP_SLOTS '(' var ',' STRING ',' STRING ')' SEMI"
607 p[0] = ast.CheckStopStatementAST(self, p[3], p[5], p[7])
608
609 def p_statement__return(self, p):
610 "statement : RETURN expr SEMI"
611 p[0] = ast.ReturnStatementAST(self, p[2])
612
613 def p_statement__if(self, p):
614 "statement : if_statement"
615 p[0] = p[1]
616
617 def p_if_statement__if(self, p):
618 "if_statement : IF '(' expr ')' statements"
619 p[0] = ast.IfStatementAST(self, p[3], p[5], None)
620
621 def p_if_statement__if_else(self, p):
622 "if_statement : IF '(' expr ')' statements ELSE statements"
623 p[0] = ast.IfStatementAST(self, p[3], p[5], p[7])
624
625 def p_statement__if_else_if(self, p):
626 "if_statement : IF '(' expr ')' statements ELSE if_statement"
627 p[0] = ast.IfStatementAST(self, p[3], p[5],
628 ast.StatementListAST(self, p[7]))
629
630 def p_expr__static_cast(self, p):
631 "aexpr : STATIC_CAST '(' type ',' expr ')'"
632 p[0] = ast.StaticCastAST(self, p[3], "ref", p[5])
633
634 def p_expr__static_cast_ptr(self, p):
635 "aexpr : STATIC_CAST '(' type ',' STRING ',' expr ')'"
636 p[0] = ast.StaticCastAST(self, p[3], p[5], p[7])
637
638 def p_expr__var(self, p):
639 "aexpr : var"
640 p[0] = p[1]
641
642 def p_expr__localvar(self, p):
643 "aexpr : type ident"
644 p[0] = ast.LocalVariableAST(self, p[1], p[2])
645
646 def p_expr__literal(self, p):
647 "aexpr : literal"
648 p[0] = p[1]
649
650 def p_expr__enumeration(self, p):
651 "aexpr : enumeration"
652 p[0] = p[1]
653
654 def p_expr__func_call(self, p):
655 "aexpr : ident '(' exprs ')'"
656 p[0] = ast.FuncCallExprAST(self, p[1], p[3])
657
658 def p_expr__new(self, p):
659 "aexpr : NEW type"
660 p[0] = ast.NewExprAST(self, p[2])
661
662 def p_expr__null(self, p):
663 "aexpr : OOD"
664 p[0] = ast.OodAST(self)
665
666 def p_expr__member(self, p):
667 "aexpr : aexpr DOT ident"
668 p[0] = ast.MemberExprAST(self, p[1], p[3])
669
670 def p_expr__member_method_call(self, p):
671 "aexpr : aexpr DOT ident '(' exprs ')'"
672 p[0] = ast.MemberMethodCallExprAST(self, p[1],
673 ast.FuncCallExprAST(self, p[3], p[5]))
674
675 def p_expr__member_method_call_lookup(self, p):
676 "aexpr : aexpr '[' exprs ']'"
677 p[0] = ast.MemberMethodCallExprAST(self, p[1],
678 ast.FuncCallExprAST(self, "lookup", p[3]))
679
680 def p_expr__class_method_call(self, p):
681 "aexpr : type DOUBLE_COLON ident '(' exprs ')'"
682 p[0] = ast.ClassMethodCallExprAST(self, p[1],
683 ast.FuncCallExprAST(self, p[3], p[5]))
684
685 def p_expr__aexpr(self, p):
686 "expr : aexpr"
687 p[0] = p[1]
688
689 def p_expr__binary_op(self, p):
690 """expr : expr STAR expr
691 | expr SLASH expr
692 | expr PLUS expr
693 | expr DASH expr
694 | expr LT expr
695 | expr GT expr
696 | expr LE expr
697 | expr GE expr
698 | expr EQ expr
699 | expr NE expr
700 | expr AND expr
701 | expr OR expr
702 | expr RIGHTSHIFT expr
703 | expr LEFTSHIFT expr"""
704 p[0] = ast.InfixOperatorExprAST(self, p[1], p[2], p[3])
705
706 # FIXME - unary not
707 def p_expr__unary_op(self, p):
708 """expr : NOT expr
709 | INCR expr
710 | DECR expr
711 | DASH expr %prec UMINUS"""
712 p[0] = ast.PrefixOperatorExprAST(self, p[1], p[2])
713
714 def p_expr__parens(self, p):
715 "aexpr : '(' expr ')'"
716 p[0] = p[2]
717
718 def p_expr__is_valid_ptr(self, p):
719 "aexpr : IS_VALID '(' var ')'"
720 p[0] = ast.IsValidPtrExprAST(self, p[3], True)
721
722 def p_expr__is_invalid_ptr(self, p):
723 "aexpr : IS_INVALID '(' var ')'"
724 p[0] = ast.IsValidPtrExprAST(self, p[3], False)
725
726 def p_literal__string(self, p):
727 "literal : STRING"
728 p[0] = ast.LiteralExprAST(self, p[1], "std::string")
729
730 def p_literal__number(self, p):
731 "literal : NUMBER"
732 p[0] = ast.LiteralExprAST(self, p[1], "int")
733
734 def p_literal__float(self, p):
735 "literal : FLOATNUMBER"
736 p[0] = ast.LiteralExprAST(self, p[1], "int")
737
738 def p_literal__bool(self, p):
739 "literal : LIT_BOOL"
740 p[0] = ast.LiteralExprAST(self, p[1], "bool")
741
742 def p_enumeration(self, p):
743 "enumeration : ident ':' ident"
744 p[0] = ast.EnumExprAST(self, ast.TypeAST(self, p[1]), p[3])
745
746 def p_var(self, p):
747 "var : ident"
748 p[0] = ast.VarExprAST(self, p[1])
263 p[0] = ast.MachineAST(self, p[3], p[4], p[7], p[9])
264
265 def p_decl__action(self, p):
266 "decl : ACTION '(' ident pairs ')' statements"
267 p[0] = ast.ActionDeclAST(self, p[3], p[4], p[6])
268
269 def p_decl__in_port(self, p):
270 "decl : IN_PORT '(' ident ',' type ',' var pairs ')' statements"
271 p[0] = ast.InPortDeclAST(self, p[3], p[5], p[7], p[8], p[10])
272
273 def p_decl__out_port(self, p):
274 "decl : OUT_PORT '(' ident ',' type ',' var pairs ')' SEMI"
275 p[0] = ast.OutPortDeclAST(self, p[3], p[5], p[7], p[8])
276
277 def p_decl__trans0(self, p):
278 "decl : TRANS '(' idents ',' idents ',' ident_or_star ')' idents"
279 p[0] = ast.TransitionDeclAST(self, [], p[3], p[5], p[7], p[9])
280
281 def p_decl__trans1(self, p):
282 "decl : TRANS '(' idents ',' idents ')' idents"
283 p[0] = ast.TransitionDeclAST(self, [], p[3], p[5], None, p[7])
284
285 def p_decl__trans2(self, p):
286 "decl : TRANS '(' idents ',' idents ',' ident_or_star ')' idents idents"
287 p[0] = ast.TransitionDeclAST(self, p[9], p[3], p[5], p[7], p[10])
288
289 def p_decl__trans3(self, p):
290 "decl : TRANS '(' idents ',' idents ')' idents idents"
291 p[0] = ast.TransitionDeclAST(self, p[7], p[3], p[5], None, p[8])
292
293 def p_decl__extern0(self, p):
294 "decl : EXTERN_TYPE '(' type pairs ')' SEMI"
295 p[4]["external"] = "yes"
296 p[0] = ast.TypeDeclAST(self, p[3], p[4], [])
297
298 def p_decl__global(self, p):
299 "decl : GLOBAL '(' type pairs ')' '{' type_members '}'"
300 p[4]["global"] = "yes"
301 p[0] = ast.TypeDeclAST(self, p[3], p[4], p[7])
302
303 def p_decl__struct(self, p):
304 "decl : STRUCT '(' type pairs ')' '{' type_members '}'"
305 p[0] = ast.TypeDeclAST(self, p[3], p[4], p[7])
306
307 def p_decl__enum(self, p):
308 "decl : ENUM '(' type pairs ')' '{' type_enums '}'"
309 p[4]["enumeration"] = "yes"
310 p[0] = ast.EnumDeclAST(self, p[3], p[4], p[7])
311
312 def p_decl__state_decl(self, p):
313 "decl : STATE_DECL '(' type pairs ')' '{' type_states '}'"
314 p[4]["enumeration"] = "yes"
315 p[4]["state_decl"] = "yes"
316 p[0] = ast.StateDeclAST(self, p[3], p[4], p[7])
317
318 # Type fields
319 def p_obj_decls__list(self, p):
320 "obj_decls : obj_decl obj_decls"
321 p[0] = [ p[1] ] + p[2]
322
323 def p_obj_decls__empty(self, p):
324 "obj_decls : empty"
325 p[0] = []
326
327 def p_type_members__list(self, p):
328 "type_members : type_member type_members"
329 p[0] = [ p[1] ] + p[2]
330
331 def p_type_members__empty(self, p):
332 "type_members : empty"
333 p[0] = []
334
335 def p_type_member__0(self, p):
336 """type_member : obj_decl
337 | func_decl
338 | func_def"""
339 p[0] = p[1]
340
341 # Member / Variable declarations
342 def p_decl__obj_decl(self, p):
343 "decl : obj_decl"
344 p[0] = p[1]
345
346 def p_obj_decl__0(self, p):
347 "obj_decl : type ident pairs SEMI"
348 p[0] = ast.ObjDeclAST(self, p[1], p[2], p[3], None, False)
349
350 def p_obj_decl__1(self, p):
351 "obj_decl : type STAR ident pairs SEMI"
352 p[0] = ast.ObjDeclAST(self, p[1], p[3], p[4], None, True)
353
354 def p_obj_decl__2(self, p):
355 "obj_decl : type ident ASSIGN expr SEMI"
356 p[0] = ast.ObjDeclAST(self, p[1], p[2], ast.PairListAST(self), p[4],
357 False)
358
359 def p_obj_decl__3(self, p):
360 "obj_decl : type STAR ident ASSIGN expr SEMI"
361 p[0] = ast.ObjDeclAST(self, p[1], p[3], ast.PairListAST(self), p[5],
362 True)
363
364 # Function definition and declaration
365 def p_decl__func_decl(self, p):
366 "decl : func_decl"
367 p[0] = p[1]
368
369 def p_func_decl__0(self, p):
370 """func_decl : void ident '(' params ')' pairs SEMI
371 | type ident '(' params ')' pairs SEMI"""
372 p[0] = ast.FuncDeclAST(self, p[1], p[2], p[4], p[6], None)
373
374 def p_func_decl__1(self, p):
375 """func_decl : void ident '(' types ')' pairs SEMI
376 | type ident '(' types ')' pairs SEMI"""
377 p[0] = ast.FuncDeclAST(self, p[1], p[2], p[4], p[6], None)
378
379 def p_decl__func_def(self, p):
380 "decl : func_def"
381 p[0] = p[1]
382
383 def p_func_def__0(self, p):
384 """func_def : void ident '(' params ')' pairs statements
385 | type ident '(' params ')' pairs statements"""
386 p[0] = ast.FuncDeclAST(self, p[1], p[2], p[4], p[6], p[7])
387
388 # Enum fields
389 def p_type_enums__list(self, p):
390 "type_enums : type_enum type_enums"
391 p[0] = [ p[1] ] + p[2]
392
393 def p_type_enums__empty(self, p):
394 "type_enums : empty"
395 p[0] = []
396
397 def p_type_enum(self, p):
398 "type_enum : ident pairs SEMI"
399 p[0] = ast.TypeFieldEnumAST(self, p[1], p[2])
400
401 # States
402 def p_type_states__list(self, p):
403 "type_states : type_state type_states"
404 p[0] = [ p[1] ] + p[2]
405
406 def p_type_states__empty(self, p):
407 "type_states : empty"
408 p[0] = []
409
410 def p_type_state(self, p):
411 "type_state : ident ',' enumeration pairs SEMI"
412 p[0] = ast.TypeFieldStateAST(self, p[1], p[3], p[4])
413
414 # Formal Param
415 def p_params__many(self, p):
416 "params : param ',' params"
417 p[0] = [ p[1] ] + p[3]
418
419 def p_params__one(self, p):
420 "params : param"
421 p[0] = [ p[1] ]
422
423 def p_params__none(self, p):
424 "params : empty"
425 p[0] = []
426
427 def p_param(self, p):
428 "param : type ident"
429 p[0] = ast.FormalParamAST(self, p[1], p[2])
430
431 def p_param__pointer(self, p):
432 "param : type STAR ident"
433 p[0] = ast.FormalParamAST(self, p[1], p[3], None, True)
434
435 def p_param__pointer_default(self, p):
436 "param : type STAR ident ASSIGN STRING"
437 p[0] = ast.FormalParamAST(self, p[1], p[3], p[5], True)
438
439 def p_param__default_number(self, p):
440 "param : type ident ASSIGN NUMBER"
441 p[0] = ast.FormalParamAST(self, p[1], p[2], p[4])
442
443 def p_param__default_bool(self, p):
444 "param : type ident ASSIGN LIT_BOOL"
445 p[0] = ast.FormalParamAST(self, p[1], p[2], p[4])
446
447 def p_param__default_string(self, p):
448 "param : type ident ASSIGN STRING"
449 p[0] = ast.FormalParamAST(self, p[1], p[2], p[4])
450
451 # Type
452 def p_types__multiple(self, p):
453 "types : type ',' types"
454 p[0] = [ p[1] ] + p[3]
455
456 def p_types__one(self, p):
457 "types : type"
458 p[0] = [ p[1] ]
459
460 def p_types__empty(self, p):
461 "types : empty"
462 p[0] = []
463
464 def p_typestr__multi(self, p):
465 "typestr : typestr DOUBLE_COLON ident"
466 p[0] = '%s::%s' % (p[1], p[3])
467
468 def p_typestr__single(self, p):
469 "typestr : ident"
470 p[0] = p[1]
471
472 def p_type__one(self, p):
473 "type : typestr"
474 p[0] = ast.TypeAST(self, p[1])
475
476 def p_void(self, p):
477 "void : VOID"
478 p[0] = ast.TypeAST(self, p[1])
479
480 # Idents and lists
481 def p_idents__braced(self, p):
482 "idents : '{' identx '}'"
483 p[0] = p[2]
484
485 def p_idents__bare(self, p):
486 "idents : ident"
487 p[0] = [ p[1] ]
488
489 def p_identx__multiple_1(self, p):
490 """identx : ident SEMI identx
491 | ident ',' identx"""
492 p[0] = [ p[1] ] + p[3]
493
494 def p_identx__multiple_2(self, p):
495 "identx : ident identx"
496 p[0] = [ p[1] ] + p[2]
497
498 def p_identx__single(self, p):
499 "identx : empty"
500 p[0] = [ ]
501
502 def p_ident(self, p):
503 "ident : IDENT"
504 p[0] = p[1]
505
506 def p_ident_or_star(self, p):
507 """ident_or_star : ident
508 | STAR"""
509 p[0] = p[1]
510
511 # Pair and pair lists
512 def p_pairs__list(self, p):
513 "pairs : ',' pairsx"
514 p[0] = p[2]
515
516 def p_pairs__empty(self, p):
517 "pairs : empty"
518 p[0] = ast.PairListAST(self)
519
520 def p_pairsx__many(self, p):
521 "pairsx : pair ',' pairsx"
522 p[0] = p[3]
523 p[0].addPair(p[1])
524
525 def p_pairsx__one(self, p):
526 "pairsx : pair"
527 p[0] = ast.PairListAST(self)
528 p[0].addPair(p[1])
529
530 def p_pair__assign(self, p):
531 """pair : ident '=' STRING
532 | ident '=' ident
533 | ident '=' NUMBER"""
534 p[0] = ast.PairAST(self, p[1], p[3])
535
536 def p_pair__literal(self, p):
537 "pair : STRING"
538 p[0] = ast.PairAST(self, "short", p[1])
539
540 # Below are the rules for action descriptions
541 def p_statements__inner(self, p):
542 "statements : '{' statements_inner '}'"
543 p[0] = ast.StatementListAST(self, p[2])
544
545 def p_statements__none(self, p):
546 "statements : '{' '}'"
547 p[0] = ast.StatementListAST(self, [])
548
549 def p_statements_inner__many(self, p):
550 "statements_inner : statement statements_inner"
551 p[0] = [ p[1] ] + p[2]
552
553 def p_statements_inner__one(self, p):
554 "statements_inner : statement"
555 p[0] = [ p[1] ]
556
557 def p_exprs__multiple(self, p):
558 "exprs : expr ',' exprs"
559 p[0] = [ p[1] ] + p[3]
560
561 def p_exprs__one(self, p):
562 "exprs : expr"
563 p[0] = [ p[1] ]
564
565 def p_exprs__empty(self, p):
566 "exprs : empty"""
567 p[0] = []
568
569 def p_statement__expression(self, p):
570 "statement : expr SEMI"
571 p[0] = ast.ExprStatementAST(self, p[1])
572
573 def p_statement__assign(self, p):
574 "statement : expr ASSIGN expr SEMI"
575 p[0] = ast.AssignStatementAST(self, p[1], p[3])
576
577 def p_statement__enqueue(self, p):
578 "statement : ENQUEUE '(' var ',' type ')' statements"
579 p[0] = ast.EnqueueStatementAST(self, p[3], p[5], None, p[7])
580
581 def p_statement__enqueue_latency(self, p):
582 "statement : ENQUEUE '(' var ',' type ',' expr ')' statements"
583 p[0] = ast.EnqueueStatementAST(self, p[3], p[5], p[7], p[9])
584
585 def p_statement__stall_and_wait(self, p):
586 "statement : STALL_AND_WAIT '(' var ',' var ')' SEMI"
587 p[0] = ast.StallAndWaitStatementAST(self, p[3], p[5])
588
589 def p_statement__peek(self, p):
590 "statement : PEEK '(' var ',' type pairs ')' statements"
591 p[0] = ast.PeekStatementAST(self, p[3], p[5], p[6], p[8], "peek")
592
593 def p_statement__check_allocate(self, p):
594 "statement : CHECK_ALLOCATE '(' var ')' SEMI"
595 p[0] = ast.CheckAllocateStatementAST(self, p[3])
596
597 def p_statement__check_next_cycle(self, p):
598 "statement : CHECK_NEXT_CYCLE '(' ')' SEMI"
599 p[0] = ast.CheckNextCycleAST(self)
600
601 def p_statement__check_stop(self, p):
602 "statement : CHECK_STOP_SLOTS '(' var ',' STRING ',' STRING ')' SEMI"
603 p[0] = ast.CheckStopStatementAST(self, p[3], p[5], p[7])
604
605 def p_statement__return(self, p):
606 "statement : RETURN expr SEMI"
607 p[0] = ast.ReturnStatementAST(self, p[2])
608
609 def p_statement__if(self, p):
610 "statement : if_statement"
611 p[0] = p[1]
612
613 def p_if_statement__if(self, p):
614 "if_statement : IF '(' expr ')' statements"
615 p[0] = ast.IfStatementAST(self, p[3], p[5], None)
616
617 def p_if_statement__if_else(self, p):
618 "if_statement : IF '(' expr ')' statements ELSE statements"
619 p[0] = ast.IfStatementAST(self, p[3], p[5], p[7])
620
621 def p_statement__if_else_if(self, p):
622 "if_statement : IF '(' expr ')' statements ELSE if_statement"
623 p[0] = ast.IfStatementAST(self, p[3], p[5],
624 ast.StatementListAST(self, p[7]))
625
626 def p_expr__static_cast(self, p):
627 "aexpr : STATIC_CAST '(' type ',' expr ')'"
628 p[0] = ast.StaticCastAST(self, p[3], "ref", p[5])
629
630 def p_expr__static_cast_ptr(self, p):
631 "aexpr : STATIC_CAST '(' type ',' STRING ',' expr ')'"
632 p[0] = ast.StaticCastAST(self, p[3], p[5], p[7])
633
634 def p_expr__var(self, p):
635 "aexpr : var"
636 p[0] = p[1]
637
638 def p_expr__localvar(self, p):
639 "aexpr : type ident"
640 p[0] = ast.LocalVariableAST(self, p[1], p[2])
641
642 def p_expr__literal(self, p):
643 "aexpr : literal"
644 p[0] = p[1]
645
646 def p_expr__enumeration(self, p):
647 "aexpr : enumeration"
648 p[0] = p[1]
649
650 def p_expr__func_call(self, p):
651 "aexpr : ident '(' exprs ')'"
652 p[0] = ast.FuncCallExprAST(self, p[1], p[3])
653
654 def p_expr__new(self, p):
655 "aexpr : NEW type"
656 p[0] = ast.NewExprAST(self, p[2])
657
658 def p_expr__null(self, p):
659 "aexpr : OOD"
660 p[0] = ast.OodAST(self)
661
662 def p_expr__member(self, p):
663 "aexpr : aexpr DOT ident"
664 p[0] = ast.MemberExprAST(self, p[1], p[3])
665
666 def p_expr__member_method_call(self, p):
667 "aexpr : aexpr DOT ident '(' exprs ')'"
668 p[0] = ast.MemberMethodCallExprAST(self, p[1],
669 ast.FuncCallExprAST(self, p[3], p[5]))
670
671 def p_expr__member_method_call_lookup(self, p):
672 "aexpr : aexpr '[' exprs ']'"
673 p[0] = ast.MemberMethodCallExprAST(self, p[1],
674 ast.FuncCallExprAST(self, "lookup", p[3]))
675
676 def p_expr__class_method_call(self, p):
677 "aexpr : type DOUBLE_COLON ident '(' exprs ')'"
678 p[0] = ast.ClassMethodCallExprAST(self, p[1],
679 ast.FuncCallExprAST(self, p[3], p[5]))
680
681 def p_expr__aexpr(self, p):
682 "expr : aexpr"
683 p[0] = p[1]
684
685 def p_expr__binary_op(self, p):
686 """expr : expr STAR expr
687 | expr SLASH expr
688 | expr PLUS expr
689 | expr DASH expr
690 | expr LT expr
691 | expr GT expr
692 | expr LE expr
693 | expr GE expr
694 | expr EQ expr
695 | expr NE expr
696 | expr AND expr
697 | expr OR expr
698 | expr RIGHTSHIFT expr
699 | expr LEFTSHIFT expr"""
700 p[0] = ast.InfixOperatorExprAST(self, p[1], p[2], p[3])
701
702 # FIXME - unary not
703 def p_expr__unary_op(self, p):
704 """expr : NOT expr
705 | INCR expr
706 | DECR expr
707 | DASH expr %prec UMINUS"""
708 p[0] = ast.PrefixOperatorExprAST(self, p[1], p[2])
709
710 def p_expr__parens(self, p):
711 "aexpr : '(' expr ')'"
712 p[0] = p[2]
713
714 def p_expr__is_valid_ptr(self, p):
715 "aexpr : IS_VALID '(' var ')'"
716 p[0] = ast.IsValidPtrExprAST(self, p[3], True)
717
718 def p_expr__is_invalid_ptr(self, p):
719 "aexpr : IS_INVALID '(' var ')'"
720 p[0] = ast.IsValidPtrExprAST(self, p[3], False)
721
722 def p_literal__string(self, p):
723 "literal : STRING"
724 p[0] = ast.LiteralExprAST(self, p[1], "std::string")
725
726 def p_literal__number(self, p):
727 "literal : NUMBER"
728 p[0] = ast.LiteralExprAST(self, p[1], "int")
729
730 def p_literal__float(self, p):
731 "literal : FLOATNUMBER"
732 p[0] = ast.LiteralExprAST(self, p[1], "int")
733
734 def p_literal__bool(self, p):
735 "literal : LIT_BOOL"
736 p[0] = ast.LiteralExprAST(self, p[1], "bool")
737
738 def p_enumeration(self, p):
739 "enumeration : ident ':' ident"
740 p[0] = ast.EnumExprAST(self, ast.TypeAST(self, p[1]), p[3])
741
742 def p_var(self, p):
743 "var : ident"
744 p[0] = ast.VarExprAST(self, p[1])