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',
|
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 ')'"
|