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 'peek' : 'PEEK',
160 'stall_and_wait' : 'STALL_AND_WAIT',
161 'wake_up_dependents' : 'WAKE_UP_DEPENDENTS',
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',
| 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 'peek' : 'PEEK',
160 'stall_and_wait' : 'STALL_AND_WAIT',
161 'wake_up_dependents' : 'WAKE_UP_DEPENDENTS',
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',
|
174 }
175
176 literals = ':[]{}(),='
177
178 tokens = [ 'EQ', 'NE', 'LT', 'GT', 'LE', 'GE',
179 'LEFTSHIFT', 'RIGHTSHIFT',
180 'NOT', 'AND', 'OR',
181 'PLUS', 'DASH', 'STAR', 'SLASH',
182 'DOUBLE_COLON', 'SEMI',
183 'ASSIGN', 'DOT',
184 'IDENT', 'LIT_BOOL', 'FLOATNUMBER', 'NUMBER', 'STRING' ]
185 tokens += reserved.values()
186
187 t_EQ = r'=='
188 t_NE = r'!='
189 t_LT = r'<'
190 t_GT = r'>'
191 t_LE = r'<='
192 t_GE = r'>='
193 t_LEFTSHIFT = r'<<'
194 t_RIGHTSHIFT = r'>>'
195 t_NOT = r'!'
196 t_AND = r'&&'
197 t_OR = r'\|\|'
198 t_PLUS = r'\+'
199 t_DASH = r'-'
200 t_STAR = r'\*'
201 t_SLASH = r'/'
202 t_DOUBLE_COLON = r'::'
203 t_SEMI = r';'
204 t_ASSIGN = r':='
205 t_DOT = r'\.'
206
207 precedence = (
208 ('left', 'AND', 'OR'),
209 ('left', 'EQ', 'NE'),
210 ('left', 'LT', 'GT', 'LE', 'GE'),
211 ('left', 'RIGHTSHIFT', 'LEFTSHIFT'),
212 ('left', 'PLUS', 'DASH'),
213 ('left', 'STAR', 'SLASH'),
214 ('right', 'NOT', 'UMINUS'),
215 )
216
217 def t_IDENT(self, t):
218 r'[a-zA-Z_][a-zA-Z_0-9]*'
219 if t.value == 'true':
220 t.type = 'LIT_BOOL'
221 t.value = True
222 return t
223
224 if t.value == 'false':
225 t.type = 'LIT_BOOL'
226 t.value = False
227 return t
228
229 # Check for reserved words
230 t.type = self.reserved.get(t.value, 'IDENT')
231 return t
232
233 def t_FLOATNUMBER(self, t):
234 '[0-9]+[.][0-9]+'
235 try:
236 t.value = float(t.value)
237 except ValueError:
238 raise TokenError("Illegal float", t)
239 return t
240
241 def t_NUMBER(self, t):
242 r'[0-9]+'
243 try:
244 t.value = int(t.value)
245 except ValueError:
246 raise TokenError("Illegal number", t)
247 return t
248
249 def t_STRING1(self, t):
250 r'\"[^"\n]*\"'
251 t.type = 'STRING'
252 t.value = t.value[1:-1]
253 return t
254
255 def t_STRING2(self, t):
256 r"\'[^'\n]*\'"
257 t.type = 'STRING'
258 t.value = t.value[1:-1]
259 return t
260
261 def p_file(self, p):
262 "file : decls"
263 p[0] = p[1]
264
265 def p_empty(self, p):
266 "empty :"
267
268 def p_decls(self, p):
269 "decls : declsx"
270 p[0] = ast.DeclListAST(self, p[1])
271
272 def p_declsx__list(self, p):
273 "declsx : decl declsx"
274 p[0] = [ p[1] ] + p[2]
275
276 def p_declsx__none(self, p):
277 "declsx : empty"
278 p[0] = []
279
280 def p_decl__machine(self, p):
281 "decl : MACHINE '(' ident pairs ')' ':' params '{' decls '}'"
282 p[0] = ast.MachineAST(self, p[3], p[4], p[7], p[9])
283
284 def p_decl__action(self, p):
285 "decl : ACTION '(' ident pairs ')' statements"
286 p[0] = ast.ActionDeclAST(self, p[3], p[4], p[6])
287
288 def p_decl__in_port(self, p):
289 "decl : IN_PORT '(' ident ',' type ',' var pairs ')' statements"
290 p[0] = ast.InPortDeclAST(self, p[3], p[5], p[7], p[8], p[10])
291
292 def p_decl__out_port(self, p):
293 "decl : OUT_PORT '(' ident ',' type ',' var pairs ')' SEMI"
294 p[0] = ast.OutPortDeclAST(self, p[3], p[5], p[7], p[8])
295
296 def p_decl__trans0(self, p):
297 "decl : TRANS '(' idents ',' idents ',' ident pairs ')' idents"
298 p[0] = ast.TransitionDeclAST(self, p[3], p[5], p[7], p[8], p[10])
299
300 def p_decl__trans1(self, p):
301 "decl : TRANS '(' idents ',' idents pairs ')' idents"
302 p[0] = ast.TransitionDeclAST(self, p[3], p[5], None, p[6], p[8])
303
304 def p_decl__extern0(self, p):
305 "decl : EXTERN_TYPE '(' type pairs ')' SEMI"
306 p[4]["external"] = "yes"
307 p[0] = ast.TypeDeclAST(self, p[3], p[4], [])
308
309 def p_decl__extern1(self, p):
310 "decl : EXTERN_TYPE '(' type pairs ')' '{' type_methods '}'"
311 p[4]["external"] = "yes"
312 p[0] = ast.TypeDeclAST(self, p[3], p[4], p[7])
313
314 def p_decl__global(self, p):
315 "decl : GLOBAL '(' type pairs ')' '{' type_members '}'"
316 p[4]["global"] = "yes"
317 p[0] = ast.TypeDeclAST(self, p[3], p[4], p[7])
318
319 def p_decl__struct(self, p):
320 "decl : STRUCT '(' type pairs ')' '{' type_members '}'"
321 p[0] = ast.TypeDeclAST(self, p[3], p[4], p[7])
322
323 def p_decl__enum(self, p):
324 "decl : ENUM '(' type pairs ')' '{' type_enums '}'"
325 p[4]["enumeration"] = "yes"
326 p[0] = ast.EnumDeclAST(self, p[3], p[4], p[7])
327
328 def p_decl__object(self, p):
329 "decl : type ident pairs SEMI"
330 p[0] = ast.ObjDeclAST(self, p[1], p[2], p[3])
331
332 def p_decl__func_decl(self, p):
333 """decl : void ident '(' params ')' pairs SEMI
334 | type ident '(' params ')' pairs SEMI"""
335 p[0] = ast.FuncDeclAST(self, p[1], p[2], p[4], p[6], None)
336
337 def p_decl__func_def(self, p):
338 """decl : void ident '(' params ')' pairs statements
339 | type ident '(' params ')' pairs statements"""
340 p[0] = ast.FuncDeclAST(self, p[1], p[2], p[4], p[6], p[7])
341
342 # Type fields
343 def p_type_members__list(self, p):
344 "type_members : type_member type_members"
345 p[0] = [ p[1] ] + p[2]
346
347 def p_type_members__empty(self, p):
348 "type_members : empty"
349 p[0] = []
350
351 def p_type_member__1(self, p):
352 "type_member : type ident pairs SEMI"
353 p[0] = ast.TypeFieldMemberAST(self, p[1], p[2], p[3], None)
354
355 def p_type_member__2(self, p):
356 "type_member : type ident ASSIGN expr SEMI"
357 p[0] = ast.TypeFieldMemberAST(self, p[1], p[2],
358 ast.PairListAST(self), p[4])
359
360 # Methods
361 def p_type_methods__list(self, p):
362 "type_methods : type_method type_methods"
363 p[0] = [ p[1] ] + p[2]
364
365 def p_type_methods(self, p):
366 "type_methods : empty"
367 p[0] = []
368
369 def p_type_method(self, p):
370 "type_method : type_or_void ident '(' types ')' pairs SEMI"
371 p[0] = ast.TypeFieldMethodAST(self, p[1], p[2], p[4], p[6])
372
373 # Enum fields
374 def p_type_enums__list(self, p):
375 "type_enums : type_enum type_enums"
376 p[0] = [ p[1] ] + p[2]
377
378 def p_type_enums__empty(self, p):
379 "type_enums : empty"
380 p[0] = []
381
382 def p_type_enum(self, p):
383 "type_enum : ident pairs SEMI"
384 p[0] = ast.TypeFieldEnumAST(self, p[1], p[2])
385
386 # Type
387 def p_types__multiple(self, p):
388 "types : type ',' types"
389 p[0] = [ p[1] ] + p[3]
390
391 def p_types__one(self, p):
392 "types : type"
393 p[0] = [ p[1] ]
394
395 def p_types__empty(self, p):
396 "types : empty"
397 p[0] = []
398
399 def p_typestr__multi(self, p):
400 "typestr : typestr DOUBLE_COLON ident"
401 p[0] = '%s::%s' % (p[1], p[3])
402
403 def p_typestr__single(self, p):
404 "typestr : ident"
405 p[0] = p[1]
406
407 def p_type__one(self, p):
408 "type : typestr"
409 p[0] = ast.TypeAST(self, p[1])
410
411 def p_void(self, p):
412 "void : VOID"
413 p[0] = ast.TypeAST(self, p[1])
414
415 def p_type_or_void(self, p):
416 """type_or_void : type
417 | void"""
418 p[0] = p[1]
419
420 # Formal Param
421 def p_params__many(self, p):
422 "params : param ',' params"
423 p[0] = [ p[1] ] + p[3]
424
425 def p_params__one(self, p):
426 "params : param"
427 p[0] = [ p[1] ]
428
429 def p_params__none(self, p):
430 "params : empty"
431 p[0] = []
432
433 def p_param(self, p):
434 "param : type ident"
435 p[0] = ast.FormalParamAST(self, p[1], p[2])
436
437 def p_param__pointer(self, p):
438 "param : type STAR ident"
439 p[0] = ast.FormalParamAST(self, p[1], p[3], None, True)
440
441 def p_param__pointer_default(self, p):
442 "param : type STAR ident '=' STRING"
443 p[0] = ast.FormalParamAST(self, p[1], p[3], p[5], True)
444
445 def p_param__default_number(self, p):
446 "param : type ident '=' NUMBER"
447 p[0] = ast.FormalParamAST(self, p[1], p[2], p[4])
448
449 def p_param__default_bool(self, p):
450 "param : type ident '=' LIT_BOOL"
451 p[0] = ast.FormalParamAST(self, p[1], p[2], p[4])
452
453 def p_param__default_string(self, p):
454 "param : type ident '=' STRING"
455 p[0] = ast.FormalParamAST(self, p[1], p[2], p[4])
456
457 # Idents and lists
458 def p_idents__braced(self, p):
459 "idents : '{' identx '}'"
460 p[0] = p[2]
461
462 def p_idents__bare(self, p):
463 "idents : ident"
464 p[0] = [ p[1] ]
465
466 def p_identx__multiple_1(self, p):
467 """identx : ident SEMI identx
468 | ident ',' identx"""
469 p[0] = [ p[1] ] + p[3]
470
471 def p_identx__multiple_2(self, p):
472 "identx : ident identx"
473 p[0] = [ p[1] ] + p[2]
474
475 def p_identx__single(self, p):
476 "identx : empty"
477 p[0] = [ ]
478
479 def p_ident(self, p):
480 "ident : IDENT"
481 p[0] = p[1]
482
483 # Pair and pair lists
484 def p_pairs__list(self, p):
485 "pairs : ',' pairsx"
486 p[0] = p[2]
487
488 def p_pairs__empty(self, p):
489 "pairs : empty"
490 p[0] = ast.PairListAST(self)
491
492 def p_pairsx__many(self, p):
493 "pairsx : pair ',' pairsx"
494 p[0] = p[3]
495 p[0].addPair(p[1])
496
497 def p_pairsx__one(self, p):
498 "pairsx : pair"
499 p[0] = ast.PairListAST(self)
500 p[0].addPair(p[1])
501
502 def p_pair__assign(self, p):
503 """pair : ident '=' STRING
504 | ident '=' ident
505 | ident '=' NUMBER"""
506 p[0] = ast.PairAST(self, p[1], p[3])
507
508 def p_pair__literal(self, p):
509 "pair : STRING"
510 p[0] = ast.PairAST(self, "short", p[1])
511
512 # Below are the rules for action descriptions
513 def p_statements__inner(self, p):
514 "statements : '{' statements_inner '}'"
515 p[0] = ast.StatementListAST(self, p[2])
516
517 def p_statements__none(self, p):
518 "statements : '{' '}'"
519 p[0] = ast.StatementListAST(self, [])
520
521 def p_statements_inner__many(self, p):
522 "statements_inner : statement statements_inner"
523 p[0] = [ p[1] ] + p[2]
524
525 def p_statements_inner__one(self, p):
526 "statements_inner : statement"
527 p[0] = [ p[1] ]
528
529 def p_exprs__multiple(self, p):
530 "exprs : expr ',' exprs"
531 p[0] = [ p[1] ] + p[3]
532
533 def p_exprs__one(self, p):
534 "exprs : expr"
535 p[0] = [ p[1] ]
536
537 def p_exprs__empty(self, p):
538 "exprs : empty"""
539 p[0] = []
540
541 def p_statement__expression(self, p):
542 "statement : expr SEMI"
543 p[0] = ast.ExprStatementAST(self, p[1])
544
545 def p_statement__assign(self, p):
546 "statement : expr ASSIGN expr SEMI"
547 p[0] = ast.AssignStatementAST(self, p[1], p[3])
548
549 def p_statement__enqueue(self, p):
550 "statement : ENQUEUE '(' var ',' type pairs ')' statements"
551 p[0] = ast.EnqueueStatementAST(self, p[3], p[5], p[6], p[8])
552
553 def p_statement__stall_and_wait(self, p):
554 "statement : STALL_AND_WAIT '(' var ',' var ')' SEMI"
555 p[0] = ast.StallAndWaitStatementAST(self, p[3], p[5])
556
557 def p_statement__wake_up_dependents(self, p):
558 "statement : WAKE_UP_DEPENDENTS '(' var ')' SEMI"
559 p[0] = ast.WakeUpDependentsStatementAST(self, p[3])
560
561 def p_statement__peek(self, p):
562 "statement : PEEK '(' var ',' type pairs ')' statements"
563 p[0] = ast.PeekStatementAST(self, p[3], p[5], p[6], p[8], "peek")
564
565 def p_statement__copy_head(self, p):
566 "statement : COPY_HEAD '(' var ',' var pairs ')' SEMI"
567 p[0] = ast.CopyHeadStatementAST(self, p[3], p[5], p[6])
568
569 def p_statement__check_allocate(self, p):
570 "statement : CHECK_ALLOCATE '(' var ')' SEMI"
571 p[0] = ast.CheckAllocateStatementAST(self, p[3])
572
573 def p_statement__check_stop(self, p):
574 "statement : CHECK_STOP_SLOTS '(' var ',' STRING ',' STRING ')' SEMI"
575 p[0] = ast.CheckStopStatementAST(self, p[3], p[5], p[7])
576
577 def p_statement__static_cast(self, p):
578 "aexpr : STATIC_CAST '(' type ',' expr ')'"
| 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__object(self, p):
332 "decl : type ident pairs SEMI"
333 p[0] = ast.ObjDeclAST(self, p[1], p[2], p[3])
334
335 def p_decl__func_decl(self, p):
336 """decl : void ident '(' params ')' pairs SEMI
337 | type ident '(' params ')' pairs SEMI"""
338 p[0] = ast.FuncDeclAST(self, p[1], p[2], p[4], p[6], None)
339
340 def p_decl__func_def(self, p):
341 """decl : void ident '(' params ')' pairs statements
342 | type ident '(' params ')' pairs statements"""
343 p[0] = ast.FuncDeclAST(self, p[1], p[2], p[4], p[6], p[7])
344
345 # Type fields
346 def p_type_members__list(self, p):
347 "type_members : type_member type_members"
348 p[0] = [ p[1] ] + p[2]
349
350 def p_type_members__empty(self, p):
351 "type_members : empty"
352 p[0] = []
353
354 def p_type_member__1(self, p):
355 "type_member : type ident pairs SEMI"
356 p[0] = ast.TypeFieldMemberAST(self, p[1], p[2], p[3], None)
357
358 def p_type_member__2(self, p):
359 "type_member : type ident ASSIGN expr SEMI"
360 p[0] = ast.TypeFieldMemberAST(self, p[1], p[2],
361 ast.PairListAST(self), p[4])
362
363 # Methods
364 def p_type_methods__list(self, p):
365 "type_methods : type_method type_methods"
366 p[0] = [ p[1] ] + p[2]
367
368 def p_type_methods(self, p):
369 "type_methods : empty"
370 p[0] = []
371
372 def p_type_method(self, p):
373 "type_method : type_or_void ident '(' types ')' pairs SEMI"
374 p[0] = ast.TypeFieldMethodAST(self, p[1], p[2], p[4], p[6])
375
376 # Enum fields
377 def p_type_enums__list(self, p):
378 "type_enums : type_enum type_enums"
379 p[0] = [ p[1] ] + p[2]
380
381 def p_type_enums__empty(self, p):
382 "type_enums : empty"
383 p[0] = []
384
385 def p_type_enum(self, p):
386 "type_enum : ident pairs SEMI"
387 p[0] = ast.TypeFieldEnumAST(self, p[1], p[2])
388
389 # Type
390 def p_types__multiple(self, p):
391 "types : type ',' types"
392 p[0] = [ p[1] ] + p[3]
393
394 def p_types__one(self, p):
395 "types : type"
396 p[0] = [ p[1] ]
397
398 def p_types__empty(self, p):
399 "types : empty"
400 p[0] = []
401
402 def p_typestr__multi(self, p):
403 "typestr : typestr DOUBLE_COLON ident"
404 p[0] = '%s::%s' % (p[1], p[3])
405
406 def p_typestr__single(self, p):
407 "typestr : ident"
408 p[0] = p[1]
409
410 def p_type__one(self, p):
411 "type : typestr"
412 p[0] = ast.TypeAST(self, p[1])
413
414 def p_void(self, p):
415 "void : VOID"
416 p[0] = ast.TypeAST(self, p[1])
417
418 def p_type_or_void(self, p):
419 """type_or_void : type
420 | void"""
421 p[0] = p[1]
422
423 # Formal Param
424 def p_params__many(self, p):
425 "params : param ',' params"
426 p[0] = [ p[1] ] + p[3]
427
428 def p_params__one(self, p):
429 "params : param"
430 p[0] = [ p[1] ]
431
432 def p_params__none(self, p):
433 "params : empty"
434 p[0] = []
435
436 def p_param(self, p):
437 "param : type ident"
438 p[0] = ast.FormalParamAST(self, p[1], p[2])
439
440 def p_param__pointer(self, p):
441 "param : type STAR ident"
442 p[0] = ast.FormalParamAST(self, p[1], p[3], None, True)
443
444 def p_param__pointer_default(self, p):
445 "param : type STAR ident '=' STRING"
446 p[0] = ast.FormalParamAST(self, p[1], p[3], p[5], True)
447
448 def p_param__default_number(self, p):
449 "param : type ident '=' NUMBER"
450 p[0] = ast.FormalParamAST(self, p[1], p[2], p[4])
451
452 def p_param__default_bool(self, p):
453 "param : type ident '=' LIT_BOOL"
454 p[0] = ast.FormalParamAST(self, p[1], p[2], p[4])
455
456 def p_param__default_string(self, p):
457 "param : type ident '=' STRING"
458 p[0] = ast.FormalParamAST(self, p[1], p[2], p[4])
459
460 # Idents and lists
461 def p_idents__braced(self, p):
462 "idents : '{' identx '}'"
463 p[0] = p[2]
464
465 def p_idents__bare(self, p):
466 "idents : ident"
467 p[0] = [ p[1] ]
468
469 def p_identx__multiple_1(self, p):
470 """identx : ident SEMI identx
471 | ident ',' identx"""
472 p[0] = [ p[1] ] + p[3]
473
474 def p_identx__multiple_2(self, p):
475 "identx : ident identx"
476 p[0] = [ p[1] ] + p[2]
477
478 def p_identx__single(self, p):
479 "identx : empty"
480 p[0] = [ ]
481
482 def p_ident(self, p):
483 "ident : IDENT"
484 p[0] = p[1]
485
486 # Pair and pair lists
487 def p_pairs__list(self, p):
488 "pairs : ',' pairsx"
489 p[0] = p[2]
490
491 def p_pairs__empty(self, p):
492 "pairs : empty"
493 p[0] = ast.PairListAST(self)
494
495 def p_pairsx__many(self, p):
496 "pairsx : pair ',' pairsx"
497 p[0] = p[3]
498 p[0].addPair(p[1])
499
500 def p_pairsx__one(self, p):
501 "pairsx : pair"
502 p[0] = ast.PairListAST(self)
503 p[0].addPair(p[1])
504
505 def p_pair__assign(self, p):
506 """pair : ident '=' STRING
507 | ident '=' ident
508 | ident '=' NUMBER"""
509 p[0] = ast.PairAST(self, p[1], p[3])
510
511 def p_pair__literal(self, p):
512 "pair : STRING"
513 p[0] = ast.PairAST(self, "short", p[1])
514
515 # Below are the rules for action descriptions
516 def p_statements__inner(self, p):
517 "statements : '{' statements_inner '}'"
518 p[0] = ast.StatementListAST(self, p[2])
519
520 def p_statements__none(self, p):
521 "statements : '{' '}'"
522 p[0] = ast.StatementListAST(self, [])
523
524 def p_statements_inner__many(self, p):
525 "statements_inner : statement statements_inner"
526 p[0] = [ p[1] ] + p[2]
527
528 def p_statements_inner__one(self, p):
529 "statements_inner : statement"
530 p[0] = [ p[1] ]
531
532 def p_exprs__multiple(self, p):
533 "exprs : expr ',' exprs"
534 p[0] = [ p[1] ] + p[3]
535
536 def p_exprs__one(self, p):
537 "exprs : expr"
538 p[0] = [ p[1] ]
539
540 def p_exprs__empty(self, p):
541 "exprs : empty"""
542 p[0] = []
543
544 def p_statement__expression(self, p):
545 "statement : expr SEMI"
546 p[0] = ast.ExprStatementAST(self, p[1])
547
548 def p_statement__assign(self, p):
549 "statement : expr ASSIGN expr SEMI"
550 p[0] = ast.AssignStatementAST(self, p[1], p[3])
551
552 def p_statement__enqueue(self, p):
553 "statement : ENQUEUE '(' var ',' type pairs ')' statements"
554 p[0] = ast.EnqueueStatementAST(self, p[3], p[5], p[6], p[8])
555
556 def p_statement__stall_and_wait(self, p):
557 "statement : STALL_AND_WAIT '(' var ',' var ')' SEMI"
558 p[0] = ast.StallAndWaitStatementAST(self, p[3], p[5])
559
560 def p_statement__wake_up_dependents(self, p):
561 "statement : WAKE_UP_DEPENDENTS '(' var ')' SEMI"
562 p[0] = ast.WakeUpDependentsStatementAST(self, p[3])
563
564 def p_statement__peek(self, p):
565 "statement : PEEK '(' var ',' type pairs ')' statements"
566 p[0] = ast.PeekStatementAST(self, p[3], p[5], p[6], p[8], "peek")
567
568 def p_statement__copy_head(self, p):
569 "statement : COPY_HEAD '(' var ',' var pairs ')' SEMI"
570 p[0] = ast.CopyHeadStatementAST(self, p[3], p[5], p[6])
571
572 def p_statement__check_allocate(self, p):
573 "statement : CHECK_ALLOCATE '(' var ')' SEMI"
574 p[0] = ast.CheckAllocateStatementAST(self, p[3])
575
576 def p_statement__check_stop(self, p):
577 "statement : CHECK_STOP_SLOTS '(' var ',' STRING ',' STRING ')' SEMI"
578 p[0] = ast.CheckStopStatementAST(self, p[3], p[5], p[7])
579
580 def p_statement__static_cast(self, p):
581 "aexpr : STATIC_CAST '(' type ',' expr ')'"
|