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