parser.py revision 7922:7532067f818e
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 'wake_up_all_dependents' : 'WAKE_UP_ALL_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__object(self, p): 333 "decl : type ident pairs SEMI" 334 p[0] = ast.ObjDeclAST(self, p[1], p[2], p[3]) 335 336 def p_decl__func_decl(self, p): 337 """decl : void ident '(' params ')' pairs SEMI 338 | type ident '(' params ')' pairs SEMI""" 339 p[0] = ast.FuncDeclAST(self, p[1], p[2], p[4], p[6], None) 340 341 def p_decl__func_def(self, p): 342 """decl : void ident '(' params ')' pairs statements 343 | type ident '(' params ')' pairs statements""" 344 p[0] = ast.FuncDeclAST(self, p[1], p[2], p[4], p[6], p[7]) 345 346 # Type fields 347 def p_type_members__list(self, p): 348 "type_members : type_member type_members" 349 p[0] = [ p[1] ] + p[2] 350 351 def p_type_members__empty(self, p): 352 "type_members : empty" 353 p[0] = [] 354 355 def p_type_member__1(self, p): 356 "type_member : type ident pairs SEMI" 357 p[0] = ast.TypeFieldMemberAST(self, p[1], p[2], p[3], None) 358 359 def p_type_member__2(self, p): 360 "type_member : type ident ASSIGN expr SEMI" 361 p[0] = ast.TypeFieldMemberAST(self, p[1], p[2], 362 ast.PairListAST(self), p[4]) 363 364 # Methods 365 def p_type_methods__list(self, p): 366 "type_methods : type_method type_methods" 367 p[0] = [ p[1] ] + p[2] 368 369 def p_type_methods(self, p): 370 "type_methods : empty" 371 p[0] = [] 372 373 def p_type_method(self, p): 374 "type_method : type_or_void ident '(' types ')' pairs SEMI" 375 p[0] = ast.TypeFieldMethodAST(self, p[1], p[2], p[4], p[6]) 376 377 # Enum fields 378 def p_type_enums__list(self, p): 379 "type_enums : type_enum type_enums" 380 p[0] = [ p[1] ] + p[2] 381 382 def p_type_enums__empty(self, p): 383 "type_enums : empty" 384 p[0] = [] 385 386 def p_type_enum(self, p): 387 "type_enum : ident pairs SEMI" 388 p[0] = ast.TypeFieldEnumAST(self, p[1], p[2]) 389 390 # Type 391 def p_types__multiple(self, p): 392 "types : type ',' types" 393 p[0] = [ p[1] ] + p[3] 394 395 def p_types__one(self, p): 396 "types : type" 397 p[0] = [ p[1] ] 398 399 def p_types__empty(self, p): 400 "types : empty" 401 p[0] = [] 402 403 def p_typestr__multi(self, p): 404 "typestr : typestr DOUBLE_COLON ident" 405 p[0] = '%s::%s' % (p[1], p[3]) 406 407 def p_typestr__single(self, p): 408 "typestr : ident" 409 p[0] = p[1] 410 411 def p_type__one(self, p): 412 "type : typestr" 413 p[0] = ast.TypeAST(self, p[1]) 414 415 def p_void(self, p): 416 "void : VOID" 417 p[0] = ast.TypeAST(self, p[1]) 418 419 def p_type_or_void(self, p): 420 """type_or_void : type 421 | void""" 422 p[0] = p[1] 423 424 # Formal Param 425 def p_params__many(self, p): 426 "params : param ',' params" 427 p[0] = [ p[1] ] + p[3] 428 429 def p_params__one(self, p): 430 "params : param" 431 p[0] = [ p[1] ] 432 433 def p_params__none(self, p): 434 "params : empty" 435 p[0] = [] 436 437 def p_param(self, p): 438 "param : type ident" 439 p[0] = ast.FormalParamAST(self, p[1], p[2]) 440 441 def p_param__pointer(self, p): 442 "param : type STAR ident" 443 p[0] = ast.FormalParamAST(self, p[1], p[3], None, True) 444 445 def p_param__pointer_default(self, p): 446 "param : type STAR ident '=' STRING" 447 p[0] = ast.FormalParamAST(self, p[1], p[3], p[5], True) 448 449 def p_param__default_number(self, p): 450 "param : type ident '=' NUMBER" 451 p[0] = ast.FormalParamAST(self, p[1], p[2], p[4]) 452 453 def p_param__default_bool(self, p): 454 "param : type ident '=' LIT_BOOL" 455 p[0] = ast.FormalParamAST(self, p[1], p[2], p[4]) 456 457 def p_param__default_string(self, p): 458 "param : type ident '=' STRING" 459 p[0] = ast.FormalParamAST(self, p[1], p[2], p[4]) 460 461 # Idents and lists 462 def p_idents__braced(self, p): 463 "idents : '{' identx '}'" 464 p[0] = p[2] 465 466 def p_idents__bare(self, p): 467 "idents : ident" 468 p[0] = [ p[1] ] 469 470 def p_identx__multiple_1(self, p): 471 """identx : ident SEMI identx 472 | ident ',' identx""" 473 p[0] = [ p[1] ] + p[3] 474 475 def p_identx__multiple_2(self, p): 476 "identx : ident identx" 477 p[0] = [ p[1] ] + p[2] 478 479 def p_identx__single(self, p): 480 "identx : empty" 481 p[0] = [ ] 482 483 def p_ident(self, p): 484 "ident : IDENT" 485 p[0] = p[1] 486 487 # Pair and pair lists 488 def p_pairs__list(self, p): 489 "pairs : ',' pairsx" 490 p[0] = p[2] 491 492 def p_pairs__empty(self, p): 493 "pairs : empty" 494 p[0] = ast.PairListAST(self) 495 496 def p_pairsx__many(self, p): 497 "pairsx : pair ',' pairsx" 498 p[0] = p[3] 499 p[0].addPair(p[1]) 500 501 def p_pairsx__one(self, p): 502 "pairsx : pair" 503 p[0] = ast.PairListAST(self) 504 p[0].addPair(p[1]) 505 506 def p_pair__assign(self, p): 507 """pair : ident '=' STRING 508 | ident '=' ident 509 | ident '=' NUMBER""" 510 p[0] = ast.PairAST(self, p[1], p[3]) 511 512 def p_pair__literal(self, p): 513 "pair : STRING" 514 p[0] = ast.PairAST(self, "short", p[1]) 515 516 # Below are the rules for action descriptions 517 def p_statements__inner(self, p): 518 "statements : '{' statements_inner '}'" 519 p[0] = ast.StatementListAST(self, p[2]) 520 521 def p_statements__none(self, p): 522 "statements : '{' '}'" 523 p[0] = ast.StatementListAST(self, []) 524 525 def p_statements_inner__many(self, p): 526 "statements_inner : statement statements_inner" 527 p[0] = [ p[1] ] + p[2] 528 529 def p_statements_inner__one(self, p): 530 "statements_inner : statement" 531 p[0] = [ p[1] ] 532 533 def p_exprs__multiple(self, p): 534 "exprs : expr ',' exprs" 535 p[0] = [ p[1] ] + p[3] 536 537 def p_exprs__one(self, p): 538 "exprs : expr" 539 p[0] = [ p[1] ] 540 541 def p_exprs__empty(self, p): 542 "exprs : empty""" 543 p[0] = [] 544 545 def p_statement__expression(self, p): 546 "statement : expr SEMI" 547 p[0] = ast.ExprStatementAST(self, p[1]) 548 549 def p_statement__assign(self, p): 550 "statement : expr ASSIGN expr SEMI" 551 p[0] = ast.AssignStatementAST(self, p[1], p[3]) 552 553 def p_statement__enqueue(self, p): 554 "statement : ENQUEUE '(' var ',' type pairs ')' statements" 555 p[0] = ast.EnqueueStatementAST(self, p[3], p[5], p[6], p[8]) 556 557 def p_statement__stall_and_wait(self, p): 558 "statement : STALL_AND_WAIT '(' var ',' var ')' SEMI" 559 p[0] = ast.StallAndWaitStatementAST(self, p[3], p[5]) 560 561 def p_statement__wake_up_dependents(self, p): 562 "statement : WAKE_UP_DEPENDENTS '(' var ')' SEMI" 563 p[0] = ast.WakeUpDependentsStatementAST(self, p[3]) 564 565 def p_statement__wake_up_all_dependents(self, p): 566 "statement : WAKE_UP_ALL_DEPENDENTS '(' ')' SEMI" 567 p[0] = ast.WakeUpAllDependentsStatementAST(self) 568 569 def p_statement__peek(self, p): 570 "statement : PEEK '(' var ',' type pairs ')' statements" 571 p[0] = ast.PeekStatementAST(self, p[3], p[5], p[6], p[8], "peek") 572 573 def p_statement__copy_head(self, p): 574 "statement : COPY_HEAD '(' var ',' var pairs ')' SEMI" 575 p[0] = ast.CopyHeadStatementAST(self, p[3], p[5], p[6]) 576 577 def p_statement__check_allocate(self, p): 578 "statement : CHECK_ALLOCATE '(' var ')' SEMI" 579 p[0] = ast.CheckAllocateStatementAST(self, p[3]) 580 581 def p_statement__check_stop(self, p): 582 "statement : CHECK_STOP_SLOTS '(' var ',' STRING ',' STRING ')' SEMI" 583 p[0] = ast.CheckStopStatementAST(self, p[3], p[5], p[7]) 584 585 def p_statement__static_cast(self, p): 586 "aexpr : STATIC_CAST '(' type ',' expr ')'" 587 p[0] = ast.StaticCastAST(self, p[3], "ref", p[5]) 588 589 def p_statement__static_cast_ptr(self, p): 590 "aexpr : STATIC_CAST '(' type ',' STRING ',' expr ')'" 591 p[0] = ast.StaticCastAST(self, p[3], p[5], p[7]) 592 593 def p_statement__return(self, p): 594 "statement : RETURN expr SEMI" 595 p[0] = ast.ReturnStatementAST(self, p[2]) 596 597 def p_statement__if(self, p): 598 "statement : if_statement" 599 p[0] = p[1] 600 601 def p_if_statement__if(self, p): 602 "if_statement : IF '(' expr ')' statements" 603 p[0] = ast.IfStatementAST(self, p[3], p[5], None) 604 605 def p_if_statement__if_else(self, p): 606 "if_statement : IF '(' expr ')' statements ELSE statements" 607 p[0] = ast.IfStatementAST(self, p[3], p[5], p[7]) 608 609 def p_statement__if_else_if(self, p): 610 "if_statement : IF '(' expr ')' statements ELSE if_statement" 611 p[0] = ast.IfStatementAST(self, p[3], p[5], 612 ast.StatementListAST(self, p[7])) 613 614 def p_expr__var(self, p): 615 "aexpr : var" 616 p[0] = p[1] 617 618 def p_expr__localvar(self, p): 619 "aexpr : type ident" 620 p[0] = ast.LocalVariableAST(self, p[1], p[2]) 621 622 def p_expr__literal(self, p): 623 "aexpr : literal" 624 p[0] = p[1] 625 626 def p_expr__enumeration(self, p): 627 "aexpr : enumeration" 628 p[0] = p[1] 629 630 def p_expr__func_call(self, p): 631 "aexpr : ident '(' exprs ')'" 632 p[0] = ast.FuncCallExprAST(self, p[1], p[3]) 633 634 def p_expr__new(self, p): 635 "aexpr : NEW type" 636 p[0] = ast.NewExprAST(self, p[2]) 637 638 def p_expr__null(self, p): 639 "aexpr : OOD" 640 p[0] = ast.OodAST(self) 641 642 # globally access a local chip component and call a method 643 def p_expr__local_chip_method(self, p): 644 "aexpr : THIS DOT var '[' expr ']' DOT var DOT ident '(' exprs ')'" 645 p[0] = ast.LocalChipMethodAST(self, p[3], p[5], p[8], p[10], p[12]) 646 647 # globally access a local chip component and access a data member 648 def p_expr__local_chip_member(self, p): 649 "aexpr : THIS DOT var '[' expr ']' DOT var DOT field" 650 p[0] = ast.LocalChipMemberAST(self, p[3], p[5], p[8], p[10]) 651 652 # globally access a specified chip component and call a method 653 def p_expr__specified_chip_method(self, p): 654 "aexpr : CHIP '[' expr ']' DOT var '[' expr ']' DOT var DOT ident '(' exprs ')'" 655 p[0] = ast.SpecifiedChipMethodAST(self, p[3], p[6], p[8], p[11], p[13], 656 p[15]) 657 658 # globally access a specified chip component and access a data member 659 def p_expr__specified_chip_member(self, p): 660 "aexpr : CHIP '[' expr ']' DOT var '[' expr ']' DOT var DOT field" 661 p[0] = ast.SpecifiedChipMemberAST(self, p[3], p[6], p[8], p[11], p[13]) 662 663 def p_expr__member(self, p): 664 "aexpr : aexpr DOT ident" 665 p[0] = ast.MemberExprAST(self, p[1], p[3]) 666 667 def p_expr__member_method_call(self, p): 668 "aexpr : aexpr DOT ident '(' exprs ')'" 669 p[0] = ast.MemberMethodCallExprAST(self, p[1], p[3], p[5]) 670 671 def p_expr__member_method_call_lookup(self, p): 672 "aexpr : aexpr '[' exprs ']'" 673 p[0] = ast.MemberMethodCallExprAST(self, p[1], "lookup", p[3]) 674 675 def p_expr__class_method_call(self, p): 676 "aexpr : type DOUBLE_COLON ident '(' exprs ')'" 677 p[0] = ast.ClassMethodCallExprAST(self, p[1], p[3], p[5]) 678 679 def p_expr__aexpr(self, p): 680 "expr : aexpr" 681 p[0] = p[1] 682 683 def p_expr__binary_op(self, p): 684 """expr : expr STAR expr 685 | expr SLASH expr 686 | expr PLUS expr 687 | expr DASH expr 688 | expr LT expr 689 | expr GT expr 690 | expr LE expr 691 | expr GE expr 692 | expr EQ expr 693 | expr NE expr 694 | expr AND expr 695 | expr OR expr 696 | expr RIGHTSHIFT expr 697 | expr LEFTSHIFT expr""" 698 p[0] = ast.InfixOperatorExprAST(self, p[1], p[2], p[3]) 699 700 # FIXME - unary not 701 def p_expr__unary_op(self, p): 702 """expr : NOT expr 703 | DASH expr %prec UMINUS""" 704 p[0] = PrefixOperatorExpr(p[1], p[2]) 705 706 def p_expr__parens(self, p): 707 "aexpr : '(' expr ')'" 708 p[0] = p[2] 709 710 def p_expr__is_valid_ptr(self, p): 711 "aexpr : IS_VALID '(' var ')'" 712 p[0] = ast.IsValidPtrExprAST(self, p[3], True) 713 714 def p_expr__is_invalid_ptr(self, p): 715 "aexpr : IS_INVALID '(' var ')'" 716 p[0] = ast.IsValidPtrExprAST(self, p[3], False) 717 718 def p_literal__string(self, p): 719 "literal : STRING" 720 p[0] = ast.LiteralExprAST(self, p[1], "std::string") 721 722 def p_literal__number(self, p): 723 "literal : NUMBER" 724 p[0] = ast.LiteralExprAST(self, p[1], "int") 725 726 def p_literal__float(self, p): 727 "literal : FLOATNUMBER" 728 p[0] = ast.LiteralExprAST(self, p[1], "int") 729 730 def p_literal__bool(self, p): 731 "literal : LIT_BOOL" 732 p[0] = ast.LiteralExprAST(self, p[1], "bool") 733 734 def p_enumeration(self, p): 735 "enumeration : ident ':' ident" 736 p[0] = ast.EnumExprAST(self, ast.TypeAST(self, p[1]), p[3]) 737 738 def p_var(self, p): 739 "var : ident" 740 p[0] = ast.VarExprAST(self, p[1]) 741 742 def p_field(self, p): 743 "field : ident" 744 p[0] = p[1] 745