parser.py (8154:f3d1493787d4) parser.py (8155:099771c7725d)
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, TokenError, ParseError
35
36import slicc.ast as ast
37import slicc.util as util
38from slicc.symbols import SymbolTable
39
40def read_slicc(sources):
41 if not isinstance(sources, (list,tuple)):
42 sources = [ sources ]
43
44 for source in sources:
45 for sm_file in file(source, "r"):
46 sm_file = sm_file.strip()
47 if not sm_file:
48 continue
49 if sm_file.startswith("#"):
50 continue
51 yield sm_file
52
53class SLICC(Grammar):
54 def __init__(self, protocol, **kwargs):
55 super(SLICC, self).__init__(**kwargs)
56 self.decl_list_vec = []
57 self.current_file = None
58 self.protocol = protocol
59 self.symtab = SymbolTable(self)
60
61 def codeFormatter(self, *args, **kwargs):
62 code = code_formatter(*args, **kwargs)
63 code['protocol'] = self.protocol
64 return code
65
66 def parse(self, filename):
67 self.current_file = filename
68 f = file(filename, 'r')
69 text = f.read()
70 try:
71 decl_list = super(SLICC, self).parse(text)
72 except (TokenError, ParseError), e:
73 sys.exit("%s: %s:%d" % (e, filename, e.token.lineno))
74 self.decl_list_vec.append(decl_list)
75 self.current_file = None
76
77 def _load(self, *filenames):
78 filenames = list(filenames)
79 while filenames:
80 f = filenames.pop(0)
81 if isinstance(f, (list, tuple)):
82 filenames[0:0] = list(f)
83 continue
84
85 yield f
86 if f.endswith(".slicc"):
87 dirname,basename = os.path.split(f)
88 filenames[0:0] = [ os.path.join(dirname, x) \
89 for x in read_slicc(f)]
90 else:
91 assert f.endswith(".sm")
92 self.parse(f)
93
94 def load(self, *filenames, **kwargs):
95 verbose = kwargs.pop("verbose", False)
96 if kwargs:
97 raise TypeError
98
99 gen = self._load(*filenames)
100 if verbose:
101 return gen
102 else:
103 # Run out the generator if we don't want the verbosity
104 for foo in gen:
105 pass
106
107 def findMachines(self):
108 for decl_list in self.decl_list_vec:
109 decl_list.findMachines()
110
111 def generate(self):
112 for decl_list in self.decl_list_vec:
113 decl_list.generate()
114
115 def writeCodeFiles(self, code_path):
116 util.makeDir(code_path)
117 self.symtab.writeCodeFiles(code_path)
118
119 def writeHTMLFiles(self, code_path):
120 util.makeDir(code_path)
121 self.symtab.writeHTMLFiles(code_path)
122
123 def files(self):
124 f = set([
125 'MachineType.cc',
126 'MachineType.hh',
127 'Types.hh' ])
128
129 for decl_list in self.decl_list_vec:
130 f |= decl_list.files()
131
132 return f
133
134 t_ignore = '\t '
135
136 # C or C++ comment (ignore)
137 def t_c_comment(self, t):
138 r'/\*(.|\n)*?\*/'
139 t.lexer.lineno += t.value.count('\n')
140
141 def t_cpp_comment(self, t):
142 r'//.*'
143
144 # Define a rule so we can track line numbers
145 def t_newline(self, t):
146 r'\n+'
147 t.lexer.lineno += len(t.value)
148
149 reserved = {
150 'global' : 'GLOBAL',
151 'machine' : 'MACHINE',
152 'in_port' : 'IN_PORT',
153 'out_port' : 'OUT_PORT',
154 'action' : 'ACTION',
155 'transition' : 'TRANS',
156 'structure' : 'STRUCT',
157 'external_type' : 'EXTERN_TYPE',
158 'enumeration' : 'ENUM',
159 'state_declaration' : 'STATE_DECL',
160 'peek' : 'PEEK',
161 'stall_and_wait' : 'STALL_AND_WAIT',
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, TokenError, ParseError
35
36import slicc.ast as ast
37import slicc.util as util
38from slicc.symbols import SymbolTable
39
40def read_slicc(sources):
41 if not isinstance(sources, (list,tuple)):
42 sources = [ sources ]
43
44 for source in sources:
45 for sm_file in file(source, "r"):
46 sm_file = sm_file.strip()
47 if not sm_file:
48 continue
49 if sm_file.startswith("#"):
50 continue
51 yield sm_file
52
53class SLICC(Grammar):
54 def __init__(self, protocol, **kwargs):
55 super(SLICC, self).__init__(**kwargs)
56 self.decl_list_vec = []
57 self.current_file = None
58 self.protocol = protocol
59 self.symtab = SymbolTable(self)
60
61 def codeFormatter(self, *args, **kwargs):
62 code = code_formatter(*args, **kwargs)
63 code['protocol'] = self.protocol
64 return code
65
66 def parse(self, filename):
67 self.current_file = filename
68 f = file(filename, 'r')
69 text = f.read()
70 try:
71 decl_list = super(SLICC, self).parse(text)
72 except (TokenError, ParseError), e:
73 sys.exit("%s: %s:%d" % (e, filename, e.token.lineno))
74 self.decl_list_vec.append(decl_list)
75 self.current_file = None
76
77 def _load(self, *filenames):
78 filenames = list(filenames)
79 while filenames:
80 f = filenames.pop(0)
81 if isinstance(f, (list, tuple)):
82 filenames[0:0] = list(f)
83 continue
84
85 yield f
86 if f.endswith(".slicc"):
87 dirname,basename = os.path.split(f)
88 filenames[0:0] = [ os.path.join(dirname, x) \
89 for x in read_slicc(f)]
90 else:
91 assert f.endswith(".sm")
92 self.parse(f)
93
94 def load(self, *filenames, **kwargs):
95 verbose = kwargs.pop("verbose", False)
96 if kwargs:
97 raise TypeError
98
99 gen = self._load(*filenames)
100 if verbose:
101 return gen
102 else:
103 # Run out the generator if we don't want the verbosity
104 for foo in gen:
105 pass
106
107 def findMachines(self):
108 for decl_list in self.decl_list_vec:
109 decl_list.findMachines()
110
111 def generate(self):
112 for decl_list in self.decl_list_vec:
113 decl_list.generate()
114
115 def writeCodeFiles(self, code_path):
116 util.makeDir(code_path)
117 self.symtab.writeCodeFiles(code_path)
118
119 def writeHTMLFiles(self, code_path):
120 util.makeDir(code_path)
121 self.symtab.writeHTMLFiles(code_path)
122
123 def files(self):
124 f = set([
125 'MachineType.cc',
126 'MachineType.hh',
127 'Types.hh' ])
128
129 for decl_list in self.decl_list_vec:
130 f |= decl_list.files()
131
132 return f
133
134 t_ignore = '\t '
135
136 # C or C++ comment (ignore)
137 def t_c_comment(self, t):
138 r'/\*(.|\n)*?\*/'
139 t.lexer.lineno += t.value.count('\n')
140
141 def t_cpp_comment(self, t):
142 r'//.*'
143
144 # Define a rule so we can track line numbers
145 def t_newline(self, t):
146 r'\n+'
147 t.lexer.lineno += len(t.value)
148
149 reserved = {
150 'global' : 'GLOBAL',
151 'machine' : 'MACHINE',
152 'in_port' : 'IN_PORT',
153 'out_port' : 'OUT_PORT',
154 'action' : 'ACTION',
155 'transition' : 'TRANS',
156 'structure' : 'STRUCT',
157 'external_type' : 'EXTERN_TYPE',
158 'enumeration' : 'ENUM',
159 'state_declaration' : 'STATE_DECL',
160 'peek' : 'PEEK',
161 'stall_and_wait' : 'STALL_AND_WAIT',
162 'wake_up_dependents' : 'WAKE_UP_DEPENDENTS',
163 'enqueue' : 'ENQUEUE',
164 'copy_head' : 'COPY_HEAD',
165 'check_allocate' : 'CHECK_ALLOCATE',
166 'check_stop_slots' : 'CHECK_STOP_SLOTS',
167 'static_cast' : 'STATIC_CAST',
168 'if' : 'IF',
169 'is_valid' : 'IS_VALID',
170 'is_invalid' : 'IS_INVALID',
171 'else' : 'ELSE',
172 'return' : 'RETURN',
173 'THIS' : 'THIS',
174 'CHIP' : 'CHIP',
175 'void' : 'VOID',
176 'new' : 'NEW',
177 'OOD' : 'OOD',
178 }
179
180 literals = ':[]{}(),='
181
182 tokens = [ 'EQ', 'NE', 'LT', 'GT', 'LE', 'GE',
183 'LEFTSHIFT', 'RIGHTSHIFT',
184 'NOT', 'AND', 'OR',
185 'PLUS', 'DASH', 'STAR', 'SLASH',
186 'DOUBLE_COLON', 'SEMI',
187 'ASSIGN', 'DOT',
188 'IDENT', 'LIT_BOOL', 'FLOATNUMBER', 'NUMBER', 'STRING' ]
189 tokens += reserved.values()
190
191 t_EQ = r'=='
192 t_NE = r'!='
193 t_LT = r'<'
194 t_GT = r'>'
195 t_LE = r'<='
196 t_GE = r'>='
197 t_LEFTSHIFT = r'<<'
198 t_RIGHTSHIFT = r'>>'
199 t_NOT = r'!'
200 t_AND = r'&&'
201 t_OR = r'\|\|'
202 t_PLUS = r'\+'
203 t_DASH = r'-'
204 t_STAR = r'\*'
205 t_SLASH = r'/'
206 t_DOUBLE_COLON = r'::'
207 t_SEMI = r';'
208 t_ASSIGN = r':='
209 t_DOT = r'\.'
210
211 precedence = (
212 ('left', 'AND', 'OR'),
213 ('left', 'EQ', 'NE'),
214 ('left', 'LT', 'GT', 'LE', 'GE'),
215 ('left', 'RIGHTSHIFT', 'LEFTSHIFT'),
216 ('left', 'PLUS', 'DASH'),
217 ('left', 'STAR', 'SLASH'),
218 ('right', 'NOT', 'UMINUS'),
219 )
220
221 def t_IDENT(self, t):
222 r'[a-zA-Z_][a-zA-Z_0-9]*'
223 if t.value == 'true':
224 t.type = 'LIT_BOOL'
225 t.value = True
226 return t
227
228 if t.value == 'false':
229 t.type = 'LIT_BOOL'
230 t.value = False
231 return t
232
233 # Check for reserved words
234 t.type = self.reserved.get(t.value, 'IDENT')
235 return t
236
237 def t_FLOATNUMBER(self, t):
238 '[0-9]+[.][0-9]+'
239 try:
240 t.value = float(t.value)
241 except ValueError:
242 raise TokenError("Illegal float", t)
243 return t
244
245 def t_NUMBER(self, t):
246 r'[0-9]+'
247 try:
248 t.value = int(t.value)
249 except ValueError:
250 raise TokenError("Illegal number", t)
251 return t
252
253 def t_STRING1(self, t):
254 r'\"[^"\n]*\"'
255 t.type = 'STRING'
256 t.value = t.value[1:-1]
257 return t
258
259 def t_STRING2(self, t):
260 r"\'[^'\n]*\'"
261 t.type = 'STRING'
262 t.value = t.value[1:-1]
263 return t
264
265 def p_file(self, p):
266 "file : decls"
267 p[0] = p[1]
268
269 def p_empty(self, p):
270 "empty :"
271
272 def p_decls(self, p):
273 "decls : declsx"
274 p[0] = ast.DeclListAST(self, p[1])
275
276 def p_declsx__list(self, p):
277 "declsx : decl declsx"
278 p[0] = [ p[1] ] + p[2]
279
280 def p_declsx__none(self, p):
281 "declsx : empty"
282 p[0] = []
283
284 def p_decl__machine(self, p):
285 "decl : MACHINE '(' ident pairs ')' ':' params '{' decls '}'"
286 p[0] = ast.MachineAST(self, p[3], p[4], p[7], p[9])
287
288 def p_decl__action(self, p):
289 "decl : ACTION '(' ident pairs ')' statements"
290 p[0] = ast.ActionDeclAST(self, p[3], p[4], p[6])
291
292 def p_decl__in_port(self, p):
293 "decl : IN_PORT '(' ident ',' type ',' var pairs ')' statements"
294 p[0] = ast.InPortDeclAST(self, p[3], p[5], p[7], p[8], p[10])
295
296 def p_decl__out_port(self, p):
297 "decl : OUT_PORT '(' ident ',' type ',' var pairs ')' SEMI"
298 p[0] = ast.OutPortDeclAST(self, p[3], p[5], p[7], p[8])
299
300 def p_decl__trans0(self, p):
301 "decl : TRANS '(' idents ',' idents ',' ident pairs ')' idents"
302 p[0] = ast.TransitionDeclAST(self, p[3], p[5], p[7], p[8], p[10])
303
304 def p_decl__trans1(self, p):
305 "decl : TRANS '(' idents ',' idents pairs ')' idents"
306 p[0] = ast.TransitionDeclAST(self, p[3], p[5], None, p[6], p[8])
307
308 def p_decl__extern0(self, p):
309 "decl : EXTERN_TYPE '(' type pairs ')' SEMI"
310 p[4]["external"] = "yes"
311 p[0] = ast.TypeDeclAST(self, p[3], p[4], [])
312
313 def p_decl__extern1(self, p):
314 "decl : EXTERN_TYPE '(' type pairs ')' '{' type_methods '}'"
315 p[4]["external"] = "yes"
316 p[0] = ast.TypeDeclAST(self, p[3], p[4], p[7])
317
318 def p_decl__global(self, p):
319 "decl : GLOBAL '(' type pairs ')' '{' type_members '}'"
320 p[4]["global"] = "yes"
321 p[0] = ast.TypeDeclAST(self, p[3], p[4], p[7])
322
323 def p_decl__struct(self, p):
324 "decl : STRUCT '(' type pairs ')' '{' type_members '}'"
325 p[0] = ast.TypeDeclAST(self, p[3], p[4], p[7])
326
327 def p_decl__enum(self, p):
328 "decl : ENUM '(' type pairs ')' '{' type_enums '}'"
329 p[4]["enumeration"] = "yes"
330 p[0] = ast.EnumDeclAST(self, p[3], p[4], p[7])
331
332 def p_decl__state_decl(self, p):
333 "decl : STATE_DECL '(' type pairs ')' '{' type_states '}'"
334 p[4]["enumeration"] = "yes"
335 p[4]["state_decl"] = "yes"
336 p[0] = ast.StateDeclAST(self, p[3], p[4], p[7])
337
338 def p_decl__object(self, p):
339 "decl : type ident pairs SEMI"
340 p[0] = ast.ObjDeclAST(self, p[1], p[2], p[3])
341
342 def p_decl__func_decl(self, p):
343 """decl : void ident '(' params ')' pairs SEMI
344 | type ident '(' params ')' pairs SEMI"""
345 p[0] = ast.FuncDeclAST(self, p[1], p[2], p[4], p[6], None)
346
347 def p_decl__func_def(self, p):
348 """decl : void ident '(' params ')' pairs statements
349 | type ident '(' params ')' pairs statements"""
350 p[0] = ast.FuncDeclAST(self, p[1], p[2], p[4], p[6], p[7])
351
352 # Type fields
353 def p_type_members__list(self, p):
354 "type_members : type_member type_members"
355 p[0] = [ p[1] ] + p[2]
356
357 def p_type_members__empty(self, p):
358 "type_members : empty"
359 p[0] = []
360
361 def p_type_member__1(self, p):
362 "type_member : type ident pairs SEMI"
363 p[0] = ast.TypeFieldMemberAST(self, p[1], p[2], p[3], None)
364
365 def p_type_member__2(self, p):
366 "type_member : type ident ASSIGN expr SEMI"
367 p[0] = ast.TypeFieldMemberAST(self, p[1], p[2],
368 ast.PairListAST(self), p[4])
369
370 # Methods
371 def p_type_methods__list(self, p):
372 "type_methods : type_method type_methods"
373 p[0] = [ p[1] ] + p[2]
374
375 def p_type_methods(self, p):
376 "type_methods : empty"
377 p[0] = []
378
379 def p_type_method(self, p):
380 "type_method : type_or_void ident '(' types ')' pairs SEMI"
381 p[0] = ast.TypeFieldMethodAST(self, p[1], p[2], p[4], p[6])
382
383 # Enum fields
384 def p_type_enums__list(self, p):
385 "type_enums : type_enum type_enums"
386 p[0] = [ p[1] ] + p[2]
387
388 def p_type_enums__empty(self, p):
389 "type_enums : empty"
390 p[0] = []
391
392 def p_type_enum(self, p):
393 "type_enum : ident pairs SEMI"
394 p[0] = ast.TypeFieldEnumAST(self, p[1], p[2])
395
396 # States
397 def p_type_states__list(self, p):
398 "type_states : type_state type_states"
399 p[0] = [ p[1] ] + p[2]
400
401 def p_type_states__empty(self, p):
402 "type_states : empty"
403 p[0] = []
404
405 def p_type_state(self, p):
406 "type_state : ident ',' enumeration pairs SEMI"
407 p[0] = ast.TypeFieldStateAST(self, p[1], p[3], p[4])
408
409 # Type
410 def p_types__multiple(self, p):
411 "types : type ',' types"
412 p[0] = [ p[1] ] + p[3]
413
414 def p_types__one(self, p):
415 "types : type"
416 p[0] = [ p[1] ]
417
418 def p_types__empty(self, p):
419 "types : empty"
420 p[0] = []
421
422 def p_typestr__multi(self, p):
423 "typestr : typestr DOUBLE_COLON ident"
424 p[0] = '%s::%s' % (p[1], p[3])
425
426 def p_typestr__single(self, p):
427 "typestr : ident"
428 p[0] = p[1]
429
430 def p_type__one(self, p):
431 "type : typestr"
432 p[0] = ast.TypeAST(self, p[1])
433
434 def p_void(self, p):
435 "void : VOID"
436 p[0] = ast.TypeAST(self, p[1])
437
438 def p_type_or_void(self, p):
439 """type_or_void : type
440 | void"""
441 p[0] = p[1]
442
443 # Formal Param
444 def p_params__many(self, p):
445 "params : param ',' params"
446 p[0] = [ p[1] ] + p[3]
447
448 def p_params__one(self, p):
449 "params : param"
450 p[0] = [ p[1] ]
451
452 def p_params__none(self, p):
453 "params : empty"
454 p[0] = []
455
456 def p_param(self, p):
457 "param : type ident"
458 p[0] = ast.FormalParamAST(self, p[1], p[2])
459
460 def p_param__pointer(self, p):
461 "param : type STAR ident"
462 p[0] = ast.FormalParamAST(self, p[1], p[3], None, True)
463
464 def p_param__pointer_default(self, p):
465 "param : type STAR ident '=' STRING"
466 p[0] = ast.FormalParamAST(self, p[1], p[3], p[5], True)
467
468 def p_param__default_number(self, p):
469 "param : type ident '=' NUMBER"
470 p[0] = ast.FormalParamAST(self, p[1], p[2], p[4])
471
472 def p_param__default_bool(self, p):
473 "param : type ident '=' LIT_BOOL"
474 p[0] = ast.FormalParamAST(self, p[1], p[2], p[4])
475
476 def p_param__default_string(self, p):
477 "param : type ident '=' STRING"
478 p[0] = ast.FormalParamAST(self, p[1], p[2], p[4])
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 # Pair and pair lists
507 def p_pairs__list(self, p):
508 "pairs : ',' pairsx"
509 p[0] = p[2]
510
511 def p_pairs__empty(self, p):
512 "pairs : empty"
513 p[0] = ast.PairListAST(self)
514
515 def p_pairsx__many(self, p):
516 "pairsx : pair ',' pairsx"
517 p[0] = p[3]
518 p[0].addPair(p[1])
519
520 def p_pairsx__one(self, p):
521 "pairsx : pair"
522 p[0] = ast.PairListAST(self)
523 p[0].addPair(p[1])
524
525 def p_pair__assign(self, p):
526 """pair : ident '=' STRING
527 | ident '=' ident
528 | ident '=' NUMBER"""
529 p[0] = ast.PairAST(self, p[1], p[3])
530
531 def p_pair__literal(self, p):
532 "pair : STRING"
533 p[0] = ast.PairAST(self, "short", p[1])
534
535 # Below are the rules for action descriptions
536 def p_statements__inner(self, p):
537 "statements : '{' statements_inner '}'"
538 p[0] = ast.StatementListAST(self, p[2])
539
540 def p_statements__none(self, p):
541 "statements : '{' '}'"
542 p[0] = ast.StatementListAST(self, [])
543
544 def p_statements_inner__many(self, p):
545 "statements_inner : statement statements_inner"
546 p[0] = [ p[1] ] + p[2]
547
548 def p_statements_inner__one(self, p):
549 "statements_inner : statement"
550 p[0] = [ p[1] ]
551
552 def p_exprs__multiple(self, p):
553 "exprs : expr ',' exprs"
554 p[0] = [ p[1] ] + p[3]
555
556 def p_exprs__one(self, p):
557 "exprs : expr"
558 p[0] = [ p[1] ]
559
560 def p_exprs__empty(self, p):
561 "exprs : empty"""
562 p[0] = []
563
564 def p_statement__expression(self, p):
565 "statement : expr SEMI"
566 p[0] = ast.ExprStatementAST(self, p[1])
567
568 def p_statement__assign(self, p):
569 "statement : expr ASSIGN expr SEMI"
570 p[0] = ast.AssignStatementAST(self, p[1], p[3])
571
572 def p_statement__enqueue(self, p):
573 "statement : ENQUEUE '(' var ',' type pairs ')' statements"
574 p[0] = ast.EnqueueStatementAST(self, p[3], p[5], p[6], p[8])
575
576 def p_statement__stall_and_wait(self, p):
577 "statement : STALL_AND_WAIT '(' var ',' var ')' SEMI"
578 p[0] = ast.StallAndWaitStatementAST(self, p[3], p[5])
579
162 'enqueue' : 'ENQUEUE',
163 'copy_head' : 'COPY_HEAD',
164 'check_allocate' : 'CHECK_ALLOCATE',
165 'check_stop_slots' : 'CHECK_STOP_SLOTS',
166 'static_cast' : 'STATIC_CAST',
167 'if' : 'IF',
168 'is_valid' : 'IS_VALID',
169 'is_invalid' : 'IS_INVALID',
170 'else' : 'ELSE',
171 'return' : 'RETURN',
172 'THIS' : 'THIS',
173 'CHIP' : 'CHIP',
174 'void' : 'VOID',
175 'new' : 'NEW',
176 'OOD' : 'OOD',
177 }
178
179 literals = ':[]{}(),='
180
181 tokens = [ 'EQ', 'NE', 'LT', 'GT', 'LE', 'GE',
182 'LEFTSHIFT', 'RIGHTSHIFT',
183 'NOT', 'AND', 'OR',
184 'PLUS', 'DASH', 'STAR', 'SLASH',
185 'DOUBLE_COLON', 'SEMI',
186 'ASSIGN', 'DOT',
187 'IDENT', 'LIT_BOOL', 'FLOATNUMBER', 'NUMBER', 'STRING' ]
188 tokens += reserved.values()
189
190 t_EQ = r'=='
191 t_NE = r'!='
192 t_LT = r'<'
193 t_GT = r'>'
194 t_LE = r'<='
195 t_GE = r'>='
196 t_LEFTSHIFT = r'<<'
197 t_RIGHTSHIFT = r'>>'
198 t_NOT = r'!'
199 t_AND = r'&&'
200 t_OR = r'\|\|'
201 t_PLUS = r'\+'
202 t_DASH = r'-'
203 t_STAR = r'\*'
204 t_SLASH = r'/'
205 t_DOUBLE_COLON = r'::'
206 t_SEMI = r';'
207 t_ASSIGN = r':='
208 t_DOT = r'\.'
209
210 precedence = (
211 ('left', 'AND', 'OR'),
212 ('left', 'EQ', 'NE'),
213 ('left', 'LT', 'GT', 'LE', 'GE'),
214 ('left', 'RIGHTSHIFT', 'LEFTSHIFT'),
215 ('left', 'PLUS', 'DASH'),
216 ('left', 'STAR', 'SLASH'),
217 ('right', 'NOT', 'UMINUS'),
218 )
219
220 def t_IDENT(self, t):
221 r'[a-zA-Z_][a-zA-Z_0-9]*'
222 if t.value == 'true':
223 t.type = 'LIT_BOOL'
224 t.value = True
225 return t
226
227 if t.value == 'false':
228 t.type = 'LIT_BOOL'
229 t.value = False
230 return t
231
232 # Check for reserved words
233 t.type = self.reserved.get(t.value, 'IDENT')
234 return t
235
236 def t_FLOATNUMBER(self, t):
237 '[0-9]+[.][0-9]+'
238 try:
239 t.value = float(t.value)
240 except ValueError:
241 raise TokenError("Illegal float", t)
242 return t
243
244 def t_NUMBER(self, t):
245 r'[0-9]+'
246 try:
247 t.value = int(t.value)
248 except ValueError:
249 raise TokenError("Illegal number", t)
250 return t
251
252 def t_STRING1(self, t):
253 r'\"[^"\n]*\"'
254 t.type = 'STRING'
255 t.value = t.value[1:-1]
256 return t
257
258 def t_STRING2(self, t):
259 r"\'[^'\n]*\'"
260 t.type = 'STRING'
261 t.value = t.value[1:-1]
262 return t
263
264 def p_file(self, p):
265 "file : decls"
266 p[0] = p[1]
267
268 def p_empty(self, p):
269 "empty :"
270
271 def p_decls(self, p):
272 "decls : declsx"
273 p[0] = ast.DeclListAST(self, p[1])
274
275 def p_declsx__list(self, p):
276 "declsx : decl declsx"
277 p[0] = [ p[1] ] + p[2]
278
279 def p_declsx__none(self, p):
280 "declsx : empty"
281 p[0] = []
282
283 def p_decl__machine(self, p):
284 "decl : MACHINE '(' ident pairs ')' ':' params '{' decls '}'"
285 p[0] = ast.MachineAST(self, p[3], p[4], p[7], p[9])
286
287 def p_decl__action(self, p):
288 "decl : ACTION '(' ident pairs ')' statements"
289 p[0] = ast.ActionDeclAST(self, p[3], p[4], p[6])
290
291 def p_decl__in_port(self, p):
292 "decl : IN_PORT '(' ident ',' type ',' var pairs ')' statements"
293 p[0] = ast.InPortDeclAST(self, p[3], p[5], p[7], p[8], p[10])
294
295 def p_decl__out_port(self, p):
296 "decl : OUT_PORT '(' ident ',' type ',' var pairs ')' SEMI"
297 p[0] = ast.OutPortDeclAST(self, p[3], p[5], p[7], p[8])
298
299 def p_decl__trans0(self, p):
300 "decl : TRANS '(' idents ',' idents ',' ident pairs ')' idents"
301 p[0] = ast.TransitionDeclAST(self, p[3], p[5], p[7], p[8], p[10])
302
303 def p_decl__trans1(self, p):
304 "decl : TRANS '(' idents ',' idents pairs ')' idents"
305 p[0] = ast.TransitionDeclAST(self, p[3], p[5], None, p[6], p[8])
306
307 def p_decl__extern0(self, p):
308 "decl : EXTERN_TYPE '(' type pairs ')' SEMI"
309 p[4]["external"] = "yes"
310 p[0] = ast.TypeDeclAST(self, p[3], p[4], [])
311
312 def p_decl__extern1(self, p):
313 "decl : EXTERN_TYPE '(' type pairs ')' '{' type_methods '}'"
314 p[4]["external"] = "yes"
315 p[0] = ast.TypeDeclAST(self, p[3], p[4], p[7])
316
317 def p_decl__global(self, p):
318 "decl : GLOBAL '(' type pairs ')' '{' type_members '}'"
319 p[4]["global"] = "yes"
320 p[0] = ast.TypeDeclAST(self, p[3], p[4], p[7])
321
322 def p_decl__struct(self, p):
323 "decl : STRUCT '(' type pairs ')' '{' type_members '}'"
324 p[0] = ast.TypeDeclAST(self, p[3], p[4], p[7])
325
326 def p_decl__enum(self, p):
327 "decl : ENUM '(' type pairs ')' '{' type_enums '}'"
328 p[4]["enumeration"] = "yes"
329 p[0] = ast.EnumDeclAST(self, p[3], p[4], p[7])
330
331 def p_decl__state_decl(self, p):
332 "decl : STATE_DECL '(' type pairs ')' '{' type_states '}'"
333 p[4]["enumeration"] = "yes"
334 p[4]["state_decl"] = "yes"
335 p[0] = ast.StateDeclAST(self, p[3], p[4], p[7])
336
337 def p_decl__object(self, p):
338 "decl : type ident pairs SEMI"
339 p[0] = ast.ObjDeclAST(self, p[1], p[2], p[3])
340
341 def p_decl__func_decl(self, p):
342 """decl : void ident '(' params ')' pairs SEMI
343 | type ident '(' params ')' pairs SEMI"""
344 p[0] = ast.FuncDeclAST(self, p[1], p[2], p[4], p[6], None)
345
346 def p_decl__func_def(self, p):
347 """decl : void ident '(' params ')' pairs statements
348 | type ident '(' params ')' pairs statements"""
349 p[0] = ast.FuncDeclAST(self, p[1], p[2], p[4], p[6], p[7])
350
351 # Type fields
352 def p_type_members__list(self, p):
353 "type_members : type_member type_members"
354 p[0] = [ p[1] ] + p[2]
355
356 def p_type_members__empty(self, p):
357 "type_members : empty"
358 p[0] = []
359
360 def p_type_member__1(self, p):
361 "type_member : type ident pairs SEMI"
362 p[0] = ast.TypeFieldMemberAST(self, p[1], p[2], p[3], None)
363
364 def p_type_member__2(self, p):
365 "type_member : type ident ASSIGN expr SEMI"
366 p[0] = ast.TypeFieldMemberAST(self, p[1], p[2],
367 ast.PairListAST(self), p[4])
368
369 # Methods
370 def p_type_methods__list(self, p):
371 "type_methods : type_method type_methods"
372 p[0] = [ p[1] ] + p[2]
373
374 def p_type_methods(self, p):
375 "type_methods : empty"
376 p[0] = []
377
378 def p_type_method(self, p):
379 "type_method : type_or_void ident '(' types ')' pairs SEMI"
380 p[0] = ast.TypeFieldMethodAST(self, p[1], p[2], p[4], p[6])
381
382 # Enum fields
383 def p_type_enums__list(self, p):
384 "type_enums : type_enum type_enums"
385 p[0] = [ p[1] ] + p[2]
386
387 def p_type_enums__empty(self, p):
388 "type_enums : empty"
389 p[0] = []
390
391 def p_type_enum(self, p):
392 "type_enum : ident pairs SEMI"
393 p[0] = ast.TypeFieldEnumAST(self, p[1], p[2])
394
395 # States
396 def p_type_states__list(self, p):
397 "type_states : type_state type_states"
398 p[0] = [ p[1] ] + p[2]
399
400 def p_type_states__empty(self, p):
401 "type_states : empty"
402 p[0] = []
403
404 def p_type_state(self, p):
405 "type_state : ident ',' enumeration pairs SEMI"
406 p[0] = ast.TypeFieldStateAST(self, p[1], p[3], p[4])
407
408 # Type
409 def p_types__multiple(self, p):
410 "types : type ',' types"
411 p[0] = [ p[1] ] + p[3]
412
413 def p_types__one(self, p):
414 "types : type"
415 p[0] = [ p[1] ]
416
417 def p_types__empty(self, p):
418 "types : empty"
419 p[0] = []
420
421 def p_typestr__multi(self, p):
422 "typestr : typestr DOUBLE_COLON ident"
423 p[0] = '%s::%s' % (p[1], p[3])
424
425 def p_typestr__single(self, p):
426 "typestr : ident"
427 p[0] = p[1]
428
429 def p_type__one(self, p):
430 "type : typestr"
431 p[0] = ast.TypeAST(self, p[1])
432
433 def p_void(self, p):
434 "void : VOID"
435 p[0] = ast.TypeAST(self, p[1])
436
437 def p_type_or_void(self, p):
438 """type_or_void : type
439 | void"""
440 p[0] = p[1]
441
442 # Formal Param
443 def p_params__many(self, p):
444 "params : param ',' params"
445 p[0] = [ p[1] ] + p[3]
446
447 def p_params__one(self, p):
448 "params : param"
449 p[0] = [ p[1] ]
450
451 def p_params__none(self, p):
452 "params : empty"
453 p[0] = []
454
455 def p_param(self, p):
456 "param : type ident"
457 p[0] = ast.FormalParamAST(self, p[1], p[2])
458
459 def p_param__pointer(self, p):
460 "param : type STAR ident"
461 p[0] = ast.FormalParamAST(self, p[1], p[3], None, True)
462
463 def p_param__pointer_default(self, p):
464 "param : type STAR ident '=' STRING"
465 p[0] = ast.FormalParamAST(self, p[1], p[3], p[5], True)
466
467 def p_param__default_number(self, p):
468 "param : type ident '=' NUMBER"
469 p[0] = ast.FormalParamAST(self, p[1], p[2], p[4])
470
471 def p_param__default_bool(self, p):
472 "param : type ident '=' LIT_BOOL"
473 p[0] = ast.FormalParamAST(self, p[1], p[2], p[4])
474
475 def p_param__default_string(self, p):
476 "param : type ident '=' STRING"
477 p[0] = ast.FormalParamAST(self, p[1], p[2], p[4])
478
479 # Idents and lists
480 def p_idents__braced(self, p):
481 "idents : '{' identx '}'"
482 p[0] = p[2]
483
484 def p_idents__bare(self, p):
485 "idents : ident"
486 p[0] = [ p[1] ]
487
488 def p_identx__multiple_1(self, p):
489 """identx : ident SEMI identx
490 | ident ',' identx"""
491 p[0] = [ p[1] ] + p[3]
492
493 def p_identx__multiple_2(self, p):
494 "identx : ident identx"
495 p[0] = [ p[1] ] + p[2]
496
497 def p_identx__single(self, p):
498 "identx : empty"
499 p[0] = [ ]
500
501 def p_ident(self, p):
502 "ident : IDENT"
503 p[0] = p[1]
504
505 # Pair and pair lists
506 def p_pairs__list(self, p):
507 "pairs : ',' pairsx"
508 p[0] = p[2]
509
510 def p_pairs__empty(self, p):
511 "pairs : empty"
512 p[0] = ast.PairListAST(self)
513
514 def p_pairsx__many(self, p):
515 "pairsx : pair ',' pairsx"
516 p[0] = p[3]
517 p[0].addPair(p[1])
518
519 def p_pairsx__one(self, p):
520 "pairsx : pair"
521 p[0] = ast.PairListAST(self)
522 p[0].addPair(p[1])
523
524 def p_pair__assign(self, p):
525 """pair : ident '=' STRING
526 | ident '=' ident
527 | ident '=' NUMBER"""
528 p[0] = ast.PairAST(self, p[1], p[3])
529
530 def p_pair__literal(self, p):
531 "pair : STRING"
532 p[0] = ast.PairAST(self, "short", p[1])
533
534 # Below are the rules for action descriptions
535 def p_statements__inner(self, p):
536 "statements : '{' statements_inner '}'"
537 p[0] = ast.StatementListAST(self, p[2])
538
539 def p_statements__none(self, p):
540 "statements : '{' '}'"
541 p[0] = ast.StatementListAST(self, [])
542
543 def p_statements_inner__many(self, p):
544 "statements_inner : statement statements_inner"
545 p[0] = [ p[1] ] + p[2]
546
547 def p_statements_inner__one(self, p):
548 "statements_inner : statement"
549 p[0] = [ p[1] ]
550
551 def p_exprs__multiple(self, p):
552 "exprs : expr ',' exprs"
553 p[0] = [ p[1] ] + p[3]
554
555 def p_exprs__one(self, p):
556 "exprs : expr"
557 p[0] = [ p[1] ]
558
559 def p_exprs__empty(self, p):
560 "exprs : empty"""
561 p[0] = []
562
563 def p_statement__expression(self, p):
564 "statement : expr SEMI"
565 p[0] = ast.ExprStatementAST(self, p[1])
566
567 def p_statement__assign(self, p):
568 "statement : expr ASSIGN expr SEMI"
569 p[0] = ast.AssignStatementAST(self, p[1], p[3])
570
571 def p_statement__enqueue(self, p):
572 "statement : ENQUEUE '(' var ',' type pairs ')' statements"
573 p[0] = ast.EnqueueStatementAST(self, p[3], p[5], p[6], p[8])
574
575 def p_statement__stall_and_wait(self, p):
576 "statement : STALL_AND_WAIT '(' var ',' var ')' SEMI"
577 p[0] = ast.StallAndWaitStatementAST(self, p[3], p[5])
578
580 def p_statement__wake_up_dependents(self, p):
581 "statement : WAKE_UP_DEPENDENTS '(' var ')' SEMI"
582 p[0] = ast.WakeUpDependentsStatementAST(self, p[3])
583
584 def p_statement__peek(self, p):
585 "statement : PEEK '(' var ',' type pairs ')' statements"
586 p[0] = ast.PeekStatementAST(self, p[3], p[5], p[6], p[8], "peek")
587
588 def p_statement__copy_head(self, p):
589 "statement : COPY_HEAD '(' var ',' var pairs ')' SEMI"
590 p[0] = ast.CopyHeadStatementAST(self, p[3], p[5], p[6])
591
592 def p_statement__check_allocate(self, p):
593 "statement : CHECK_ALLOCATE '(' var ')' SEMI"
594 p[0] = ast.CheckAllocateStatementAST(self, p[3])
595
596 def p_statement__check_stop(self, p):
597 "statement : CHECK_STOP_SLOTS '(' var ',' STRING ',' STRING ')' SEMI"
598 p[0] = ast.CheckStopStatementAST(self, p[3], p[5], p[7])
599
600 def p_statement__static_cast(self, p):
601 "aexpr : STATIC_CAST '(' type ',' expr ')'"
602 p[0] = ast.StaticCastAST(self, p[3], "ref", p[5])
603
604 def p_statement__static_cast_ptr(self, p):
605 "aexpr : STATIC_CAST '(' type ',' STRING ',' expr ')'"
606 p[0] = ast.StaticCastAST(self, p[3], p[5], p[7])
607
608 def p_statement__return(self, p):
609 "statement : RETURN expr SEMI"
610 p[0] = ast.ReturnStatementAST(self, p[2])
611
612 def p_statement__if(self, p):
613 "statement : if_statement"
614 p[0] = p[1]
615
616 def p_if_statement__if(self, p):
617 "if_statement : IF '(' expr ')' statements"
618 p[0] = ast.IfStatementAST(self, p[3], p[5], None)
619
620 def p_if_statement__if_else(self, p):
621 "if_statement : IF '(' expr ')' statements ELSE statements"
622 p[0] = ast.IfStatementAST(self, p[3], p[5], p[7])
623
624 def p_statement__if_else_if(self, p):
625 "if_statement : IF '(' expr ')' statements ELSE if_statement"
626 p[0] = ast.IfStatementAST(self, p[3], p[5],
627 ast.StatementListAST(self, p[7]))
628
629 def p_expr__var(self, p):
630 "aexpr : var"
631 p[0] = p[1]
632
633 def p_expr__localvar(self, p):
634 "aexpr : type ident"
635 p[0] = ast.LocalVariableAST(self, p[1], p[2])
636
637 def p_expr__literal(self, p):
638 "aexpr : literal"
639 p[0] = p[1]
640
641 def p_expr__enumeration(self, p):
642 "aexpr : enumeration"
643 p[0] = p[1]
644
645 def p_expr__func_call(self, p):
646 "aexpr : ident '(' exprs ')'"
647 p[0] = ast.FuncCallExprAST(self, p[1], p[3])
648
649 def p_expr__new(self, p):
650 "aexpr : NEW type"
651 p[0] = ast.NewExprAST(self, p[2])
652
653 def p_expr__null(self, p):
654 "aexpr : OOD"
655 p[0] = ast.OodAST(self)
656
657 # globally access a local chip component and call a method
658 def p_expr__local_chip_method(self, p):
659 "aexpr : THIS DOT var '[' expr ']' DOT var DOT ident '(' exprs ')'"
660 p[0] = ast.LocalChipMethodAST(self, p[3], p[5], p[8], p[10], p[12])
661
662 # globally access a local chip component and access a data member
663 def p_expr__local_chip_member(self, p):
664 "aexpr : THIS DOT var '[' expr ']' DOT var DOT field"
665 p[0] = ast.LocalChipMemberAST(self, p[3], p[5], p[8], p[10])
666
667 # globally access a specified chip component and call a method
668 def p_expr__specified_chip_method(self, p):
669 "aexpr : CHIP '[' expr ']' DOT var '[' expr ']' DOT var DOT ident '(' exprs ')'"
670 p[0] = ast.SpecifiedChipMethodAST(self, p[3], p[6], p[8], p[11], p[13],
671 p[15])
672
673 # globally access a specified chip component and access a data member
674 def p_expr__specified_chip_member(self, p):
675 "aexpr : CHIP '[' expr ']' DOT var '[' expr ']' DOT var DOT field"
676 p[0] = ast.SpecifiedChipMemberAST(self, p[3], p[6], p[8], p[11], p[13])
677
678 def p_expr__member(self, p):
679 "aexpr : aexpr DOT ident"
680 p[0] = ast.MemberExprAST(self, p[1], p[3])
681
682 def p_expr__member_method_call(self, p):
683 "aexpr : aexpr DOT ident '(' exprs ')'"
684 p[0] = ast.MemberMethodCallExprAST(self, p[1], p[3], p[5])
685
686 def p_expr__member_method_call_lookup(self, p):
687 "aexpr : aexpr '[' exprs ']'"
688 p[0] = ast.MemberMethodCallExprAST(self, p[1], "lookup", p[3])
689
690 def p_expr__class_method_call(self, p):
691 "aexpr : type DOUBLE_COLON ident '(' exprs ')'"
692 p[0] = ast.ClassMethodCallExprAST(self, p[1], p[3], p[5])
693
694 def p_expr__aexpr(self, p):
695 "expr : aexpr"
696 p[0] = p[1]
697
698 def p_expr__binary_op(self, p):
699 """expr : expr STAR expr
700 | expr SLASH expr
701 | expr PLUS expr
702 | expr DASH expr
703 | expr LT expr
704 | expr GT expr
705 | expr LE expr
706 | expr GE expr
707 | expr EQ expr
708 | expr NE expr
709 | expr AND expr
710 | expr OR expr
711 | expr RIGHTSHIFT expr
712 | expr LEFTSHIFT expr"""
713 p[0] = ast.InfixOperatorExprAST(self, p[1], p[2], p[3])
714
715 # FIXME - unary not
716 def p_expr__unary_op(self, p):
717 """expr : NOT expr
718 | DASH expr %prec UMINUS"""
719 p[0] = PrefixOperatorExpr(p[1], p[2])
720
721 def p_expr__parens(self, p):
722 "aexpr : '(' expr ')'"
723 p[0] = p[2]
724
725 def p_expr__is_valid_ptr(self, p):
726 "aexpr : IS_VALID '(' var ')'"
727 p[0] = ast.IsValidPtrExprAST(self, p[3], True)
728
729 def p_expr__is_invalid_ptr(self, p):
730 "aexpr : IS_INVALID '(' var ')'"
731 p[0] = ast.IsValidPtrExprAST(self, p[3], False)
732
733 def p_literal__string(self, p):
734 "literal : STRING"
735 p[0] = ast.LiteralExprAST(self, p[1], "std::string")
736
737 def p_literal__number(self, p):
738 "literal : NUMBER"
739 p[0] = ast.LiteralExprAST(self, p[1], "int")
740
741 def p_literal__float(self, p):
742 "literal : FLOATNUMBER"
743 p[0] = ast.LiteralExprAST(self, p[1], "int")
744
745 def p_literal__bool(self, p):
746 "literal : LIT_BOOL"
747 p[0] = ast.LiteralExprAST(self, p[1], "bool")
748
749 def p_enumeration(self, p):
750 "enumeration : ident ':' ident"
751 p[0] = ast.EnumExprAST(self, ast.TypeAST(self, p[1]), p[3])
752
753 def p_var(self, p):
754 "var : ident"
755 p[0] = ast.VarExprAST(self, p[1])
756
757 def p_field(self, p):
758 "field : ident"
759 p[0] = p[1]
579 def p_statement__peek(self, p):
580 "statement : PEEK '(' var ',' type pairs ')' statements"
581 p[0] = ast.PeekStatementAST(self, p[3], p[5], p[6], p[8], "peek")
582
583 def p_statement__copy_head(self, p):
584 "statement : COPY_HEAD '(' var ',' var pairs ')' SEMI"
585 p[0] = ast.CopyHeadStatementAST(self, p[3], p[5], p[6])
586
587 def p_statement__check_allocate(self, p):
588 "statement : CHECK_ALLOCATE '(' var ')' SEMI"
589 p[0] = ast.CheckAllocateStatementAST(self, p[3])
590
591 def p_statement__check_stop(self, p):
592 "statement : CHECK_STOP_SLOTS '(' var ',' STRING ',' STRING ')' SEMI"
593 p[0] = ast.CheckStopStatementAST(self, p[3], p[5], p[7])
594
595 def p_statement__static_cast(self, p):
596 "aexpr : STATIC_CAST '(' type ',' expr ')'"
597 p[0] = ast.StaticCastAST(self, p[3], "ref", p[5])
598
599 def p_statement__static_cast_ptr(self, p):
600 "aexpr : STATIC_CAST '(' type ',' STRING ',' expr ')'"
601 p[0] = ast.StaticCastAST(self, p[3], p[5], p[7])
602
603 def p_statement__return(self, p):
604 "statement : RETURN expr SEMI"
605 p[0] = ast.ReturnStatementAST(self, p[2])
606
607 def p_statement__if(self, p):
608 "statement : if_statement"
609 p[0] = p[1]
610
611 def p_if_statement__if(self, p):
612 "if_statement : IF '(' expr ')' statements"
613 p[0] = ast.IfStatementAST(self, p[3], p[5], None)
614
615 def p_if_statement__if_else(self, p):
616 "if_statement : IF '(' expr ')' statements ELSE statements"
617 p[0] = ast.IfStatementAST(self, p[3], p[5], p[7])
618
619 def p_statement__if_else_if(self, p):
620 "if_statement : IF '(' expr ')' statements ELSE if_statement"
621 p[0] = ast.IfStatementAST(self, p[3], p[5],
622 ast.StatementListAST(self, p[7]))
623
624 def p_expr__var(self, p):
625 "aexpr : var"
626 p[0] = p[1]
627
628 def p_expr__localvar(self, p):
629 "aexpr : type ident"
630 p[0] = ast.LocalVariableAST(self, p[1], p[2])
631
632 def p_expr__literal(self, p):
633 "aexpr : literal"
634 p[0] = p[1]
635
636 def p_expr__enumeration(self, p):
637 "aexpr : enumeration"
638 p[0] = p[1]
639
640 def p_expr__func_call(self, p):
641 "aexpr : ident '(' exprs ')'"
642 p[0] = ast.FuncCallExprAST(self, p[1], p[3])
643
644 def p_expr__new(self, p):
645 "aexpr : NEW type"
646 p[0] = ast.NewExprAST(self, p[2])
647
648 def p_expr__null(self, p):
649 "aexpr : OOD"
650 p[0] = ast.OodAST(self)
651
652 # globally access a local chip component and call a method
653 def p_expr__local_chip_method(self, p):
654 "aexpr : THIS DOT var '[' expr ']' DOT var DOT ident '(' exprs ')'"
655 p[0] = ast.LocalChipMethodAST(self, p[3], p[5], p[8], p[10], p[12])
656
657 # globally access a local chip component and access a data member
658 def p_expr__local_chip_member(self, p):
659 "aexpr : THIS DOT var '[' expr ']' DOT var DOT field"
660 p[0] = ast.LocalChipMemberAST(self, p[3], p[5], p[8], p[10])
661
662 # globally access a specified chip component and call a method
663 def p_expr__specified_chip_method(self, p):
664 "aexpr : CHIP '[' expr ']' DOT var '[' expr ']' DOT var DOT ident '(' exprs ')'"
665 p[0] = ast.SpecifiedChipMethodAST(self, p[3], p[6], p[8], p[11], p[13],
666 p[15])
667
668 # globally access a specified chip component and access a data member
669 def p_expr__specified_chip_member(self, p):
670 "aexpr : CHIP '[' expr ']' DOT var '[' expr ']' DOT var DOT field"
671 p[0] = ast.SpecifiedChipMemberAST(self, p[3], p[6], p[8], p[11], p[13])
672
673 def p_expr__member(self, p):
674 "aexpr : aexpr DOT ident"
675 p[0] = ast.MemberExprAST(self, p[1], p[3])
676
677 def p_expr__member_method_call(self, p):
678 "aexpr : aexpr DOT ident '(' exprs ')'"
679 p[0] = ast.MemberMethodCallExprAST(self, p[1], p[3], p[5])
680
681 def p_expr__member_method_call_lookup(self, p):
682 "aexpr : aexpr '[' exprs ']'"
683 p[0] = ast.MemberMethodCallExprAST(self, p[1], "lookup", p[3])
684
685 def p_expr__class_method_call(self, p):
686 "aexpr : type DOUBLE_COLON ident '(' exprs ')'"
687 p[0] = ast.ClassMethodCallExprAST(self, p[1], p[3], p[5])
688
689 def p_expr__aexpr(self, p):
690 "expr : aexpr"
691 p[0] = p[1]
692
693 def p_expr__binary_op(self, p):
694 """expr : expr STAR expr
695 | expr SLASH expr
696 | expr PLUS expr
697 | expr DASH expr
698 | expr LT expr
699 | expr GT expr
700 | expr LE expr
701 | expr GE expr
702 | expr EQ expr
703 | expr NE expr
704 | expr AND expr
705 | expr OR expr
706 | expr RIGHTSHIFT expr
707 | expr LEFTSHIFT expr"""
708 p[0] = ast.InfixOperatorExprAST(self, p[1], p[2], p[3])
709
710 # FIXME - unary not
711 def p_expr__unary_op(self, p):
712 """expr : NOT expr
713 | DASH expr %prec UMINUS"""
714 p[0] = PrefixOperatorExpr(p[1], p[2])
715
716 def p_expr__parens(self, p):
717 "aexpr : '(' expr ')'"
718 p[0] = p[2]
719
720 def p_expr__is_valid_ptr(self, p):
721 "aexpr : IS_VALID '(' var ')'"
722 p[0] = ast.IsValidPtrExprAST(self, p[3], True)
723
724 def p_expr__is_invalid_ptr(self, p):
725 "aexpr : IS_INVALID '(' var ')'"
726 p[0] = ast.IsValidPtrExprAST(self, p[3], False)
727
728 def p_literal__string(self, p):
729 "literal : STRING"
730 p[0] = ast.LiteralExprAST(self, p[1], "std::string")
731
732 def p_literal__number(self, p):
733 "literal : NUMBER"
734 p[0] = ast.LiteralExprAST(self, p[1], "int")
735
736 def p_literal__float(self, p):
737 "literal : FLOATNUMBER"
738 p[0] = ast.LiteralExprAST(self, p[1], "int")
739
740 def p_literal__bool(self, p):
741 "literal : LIT_BOOL"
742 p[0] = ast.LiteralExprAST(self, p[1], "bool")
743
744 def p_enumeration(self, p):
745 "enumeration : ident ':' ident"
746 p[0] = ast.EnumExprAST(self, ast.TypeAST(self, p[1]), p[3])
747
748 def p_var(self, p):
749 "var : ident"
750 p[0] = ast.VarExprAST(self, p[1])
751
752 def p_field(self, p):
753 "field : ident"
754 p[0] = p[1]