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