parser.py revision 10307:6df951dcd7d9
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, ParseError 35 36import slicc.ast as ast 37import slicc.util as util 38from slicc.symbols import SymbolTable 39 40class SLICC(Grammar): 41 def __init__(self, filename, base_dir, verbose=False, traceback=False, **kwargs): 42 self.protocol = None 43 self.traceback = traceback 44 self.verbose = verbose 45 self.symtab = SymbolTable(self) 46 self.base_dir = base_dir 47 48 try: 49 self.decl_list = self.parse_file(filename, **kwargs) 50 except ParseError, e: 51 if not self.traceback: 52 sys.exit(str(e)) 53 raise 54 55 def currentLocation(self): 56 return util.Location(self.current_source, self.current_line, 57 no_warning=not self.verbose) 58 59 def codeFormatter(self, *args, **kwargs): 60 code = code_formatter(*args, **kwargs) 61 code['protocol'] = self.protocol 62 return code 63 64 def process(self): 65 self.decl_list.findMachines() 66 self.decl_list.generate() 67 68 def writeCodeFiles(self, code_path, includes): 69 self.symtab.writeCodeFiles(code_path, includes) 70 71 def writeHTMLFiles(self, html_path): 72 self.symtab.writeHTMLFiles(html_path) 73 74 def files(self): 75 f = set([ 76 'MachineType.cc', 77 'MachineType.hh', 78 'Types.hh' ]) 79 80 f |= self.decl_list.files() 81 82 return f 83 84 t_ignore = '\t ' 85 86 # C or C++ comment (ignore) 87 def t_c_comment(self, t): 88 r'/\*(.|\n)*?\*/' 89 t.lexer.lineno += t.value.count('\n') 90 91 def t_cpp_comment(self, t): 92 r'//.*' 93 94 # Define a rule so we can track line numbers 95 def t_newline(self, t): 96 r'\n+' 97 t.lexer.lineno += len(t.value) 98 99 reserved = { 100 'protocol' : 'PROTOCOL', 101 'include' : 'INCLUDE', 102 'global' : 'GLOBAL', 103 'machine' : 'MACHINE', 104 'in_port' : 'IN_PORT', 105 'out_port' : 'OUT_PORT', 106 'action' : 'ACTION', 107 'transition' : 'TRANS', 108 'structure' : 'STRUCT', 109 'external_type' : 'EXTERN_TYPE', 110 'enumeration' : 'ENUM', 111 'state_declaration' : 'STATE_DECL', 112 'peek' : 'PEEK', 113 'stall_and_wait' : 'STALL_AND_WAIT', 114 'enqueue' : 'ENQUEUE', 115 'check_allocate' : 'CHECK_ALLOCATE', 116 'check_stop_slots' : 'CHECK_STOP_SLOTS', 117 'static_cast' : 'STATIC_CAST', 118 'if' : 'IF', 119 'is_valid' : 'IS_VALID', 120 'is_invalid' : 'IS_INVALID', 121 'else' : 'ELSE', 122 'return' : 'RETURN', 123 'void' : 'VOID', 124 'new' : 'NEW', 125 'OOD' : 'OOD', 126 } 127 128 literals = ':[]{}(),=' 129 130 tokens = [ 'EQ', 'NE', 'LT', 'GT', 'LE', 'GE', 131 'LEFTSHIFT', 'RIGHTSHIFT', 132 'NOT', 'AND', 'OR', 133 'PLUS', 'DASH', 'STAR', 'SLASH', 134 'INCR', 'DECR', 135 'DOUBLE_COLON', 'SEMI', 136 'ASSIGN', 'DOT', 137 'IDENT', 'LIT_BOOL', 'FLOATNUMBER', 'NUMBER', 'STRING' ] 138 tokens += reserved.values() 139 140 t_EQ = r'==' 141 t_NE = r'!=' 142 t_LT = r'<' 143 t_GT = r'>' 144 t_LE = r'<=' 145 t_GE = r'>=' 146 t_LEFTSHIFT = r'<<' 147 t_RIGHTSHIFT = r'>>' 148 t_NOT = r'!' 149 t_AND = r'&&' 150 t_OR = r'\|\|' 151 t_PLUS = r'\+' 152 t_DASH = r'-' 153 t_STAR = r'\*' 154 t_SLASH = r'/' 155 t_DOUBLE_COLON = r'::' 156 t_SEMI = r';' 157 t_ASSIGN = r':=' 158 t_DOT = r'\.' 159 t_INCR = r'\+\+' 160 t_DECR = r'--' 161 162 precedence = ( 163 ('left', 'INCR', 'DECR'), 164 ('left', 'AND', 'OR'), 165 ('left', 'EQ', 'NE'), 166 ('left', 'LT', 'GT', 'LE', 'GE'), 167 ('left', 'RIGHTSHIFT', 'LEFTSHIFT'), 168 ('left', 'PLUS', 'DASH'), 169 ('left', 'STAR', 'SLASH'), 170 ('right', 'NOT', 'UMINUS'), 171 ) 172 173 def t_IDENT(self, t): 174 r'[a-zA-Z_][a-zA-Z_0-9]*' 175 if t.value == 'true': 176 t.type = 'LIT_BOOL' 177 t.value = True 178 return t 179 180 if t.value == 'false': 181 t.type = 'LIT_BOOL' 182 t.value = False 183 return t 184 185 # Check for reserved words 186 t.type = self.reserved.get(t.value, 'IDENT') 187 return t 188 189 def t_FLOATNUMBER(self, t): 190 '[0-9]+[.][0-9]+' 191 try: 192 t.value = float(t.value) 193 except ValueError: 194 raise ParseError("Illegal float", t) 195 return t 196 197 def t_NUMBER(self, t): 198 r'[0-9]+' 199 try: 200 t.value = int(t.value) 201 except ValueError: 202 raise ParseError("Illegal number", t) 203 return t 204 205 def t_STRING1(self, t): 206 r'\"[^"\n]*\"' 207 t.type = 'STRING' 208 t.value = t.value[1:-1] 209 return t 210 211 def t_STRING2(self, t): 212 r"\'[^'\n]*\'" 213 t.type = 'STRING' 214 t.value = t.value[1:-1] 215 return t 216 217 def p_file(self, p): 218 "file : decls" 219 p[0] = p[1] 220 221 def p_empty(self, p): 222 "empty :" 223 224 def p_decls(self, p): 225 "decls : declsx" 226 p[0] = ast.DeclListAST(self, p[1]) 227 228 def p_declsx__list(self, p): 229 "declsx : decl declsx" 230 if isinstance(p[1], ast.DeclListAST): 231 decls = p[1].decls 232 elif p[1] is None: 233 decls = [] 234 else: 235 decls = [ p[1] ] 236 p[0] = decls + p[2] 237 238 def p_declsx__none(self, p): 239 "declsx : empty" 240 p[0] = [] 241 242 def p_decl__protocol(self, p): 243 "decl : PROTOCOL STRING SEMI" 244 if self.protocol: 245 msg = "Protocol can only be set once! Error at %s:%s\n" % \ 246 (self.current_source, self.current_line) 247 raise ParseError(msg) 248 self.protocol = p[2] 249 p[0] = None 250 251 def p_decl__include(self, p): 252 "decl : INCLUDE STRING SEMI" 253 dirname = os.path.dirname(self.current_source) 254 if os.path.exists(os.path.join(dirname, p[2])): 255 filename = os.path.join(dirname, p[2]) 256 else: 257 filename = os.path.join(self.base_dir, p[2]) 258 p[0] = self.parse_file(filename) 259 260 def p_decl__machine0(self, p): 261 "decl : MACHINE '(' idents ')' ':' params '{' decls '}'" 262 p[0] = ast.MachineAST(self, p[3], [], p[7], p[9]) 263 264 def p_decl__machine1(self, p): 265 "decl : MACHINE '(' idents pairs ')' ':' params '{' decls '}'" 266 p[0] = ast.MachineAST(self, p[3], p[4], p[7], p[9]) 267 268 def p_decl__action(self, p): 269 "decl : ACTION '(' ident pairs ')' statements" 270 p[0] = ast.ActionDeclAST(self, p[3], p[4], p[6]) 271 272 def p_decl__in_port(self, p): 273 "decl : IN_PORT '(' ident ',' type ',' var pairs ')' statements" 274 p[0] = ast.InPortDeclAST(self, p[3], p[5], p[7], p[8], p[10]) 275 276 def p_decl__out_port(self, p): 277 "decl : OUT_PORT '(' ident ',' type ',' var pairs ')' SEMI" 278 p[0] = ast.OutPortDeclAST(self, p[3], p[5], p[7], p[8]) 279 280 def p_decl__trans0(self, p): 281 "decl : TRANS '(' idents ',' idents ',' ident ')' idents" 282 p[0] = ast.TransitionDeclAST(self, [], p[3], p[5], p[7], p[9]) 283 284 def p_decl__trans1(self, p): 285 "decl : TRANS '(' idents ',' idents ')' idents" 286 p[0] = ast.TransitionDeclAST(self, [], p[3], p[5], None, p[7]) 287 288 def p_decl__trans2(self, p): 289 "decl : TRANS '(' idents ',' idents ',' ident ')' idents idents" 290 p[0] = ast.TransitionDeclAST(self, p[9], p[3], p[5], p[7], p[10]) 291 292 def p_decl__trans3(self, p): 293 "decl : TRANS '(' idents ',' idents ')' idents idents" 294 p[0] = ast.TransitionDeclAST(self, p[7], p[3], p[5], None, 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__global(self, p): 302 "decl : GLOBAL '(' type pairs ')' '{' type_members '}'" 303 p[4]["global"] = "yes" 304 p[0] = ast.TypeDeclAST(self, p[3], p[4], p[7]) 305 306 def p_decl__struct(self, p): 307 "decl : STRUCT '(' type pairs ')' '{' type_members '}'" 308 p[0] = ast.TypeDeclAST(self, p[3], p[4], p[7]) 309 310 def p_decl__enum(self, p): 311 "decl : ENUM '(' type pairs ')' '{' type_enums '}'" 312 p[4]["enumeration"] = "yes" 313 p[0] = ast.EnumDeclAST(self, p[3], p[4], p[7]) 314 315 def p_decl__state_decl(self, p): 316 "decl : STATE_DECL '(' type pairs ')' '{' type_states '}'" 317 p[4]["enumeration"] = "yes" 318 p[4]["state_decl"] = "yes" 319 p[0] = ast.StateDeclAST(self, p[3], p[4], p[7]) 320 321 # Type fields 322 def p_type_members__list(self, p): 323 "type_members : type_member type_members" 324 p[0] = [ p[1] ] + p[2] 325 326 def p_type_members__empty(self, p): 327 "type_members : empty" 328 p[0] = [] 329 330 def p_type_member__0(self, p): 331 """type_member : obj_decl 332 | func_decl 333 | func_def""" 334 p[0] = p[1] 335 336 # Member / Variable declarations 337 def p_decl__obj_decl(self, p): 338 "decl : obj_decl" 339 p[0] = p[1] 340 341 def p_obj_decl__0(self, p): 342 "obj_decl : type ident pairs SEMI" 343 p[0] = ast.ObjDeclAST(self, p[1], p[2], p[3], None) 344 345 def p_obj_decl__1(self, p): 346 "obj_decl : type STAR ident pairs SEMI" 347 p[0] = ast.ObjDeclAST(self, p[1], p[3], p[4], None) 348 349 def p_obj_decl__2(self, p): 350 "obj_decl : type ident ASSIGN expr SEMI" 351 p[0] = ast.ObjDeclAST(self, p[1], p[2], ast.PairListAST(self), p[4]) 352 353 def p_obj_decl__3(self, p): 354 "obj_decl : type STAR ident ASSIGN expr SEMI" 355 p[0] = ast.ObjDeclAST(self, p[1], p[3], ast.PairListAST(self), p[5]) 356 357 # Function definition and declaration 358 def p_decl__func_decl(self, p): 359 "decl : func_decl" 360 p[0] = p[1] 361 362 def p_func_decl__0(self, p): 363 """func_decl : void ident '(' params ')' pairs SEMI 364 | type ident '(' params ')' pairs SEMI""" 365 p[0] = ast.FuncDeclAST(self, p[1], p[2], p[4], p[6], None) 366 367 def p_func_decl__1(self, p): 368 """func_decl : void ident '(' types ')' pairs SEMI 369 | type ident '(' types ')' pairs SEMI""" 370 p[0] = ast.FuncDeclAST(self, p[1], p[2], p[4], p[6], None) 371 372 def p_decl__func_def(self, p): 373 "decl : func_def" 374 p[0] = p[1] 375 376 def p_func_def__0(self, p): 377 """func_def : void ident '(' params ')' pairs statements 378 | type ident '(' params ')' pairs statements""" 379 p[0] = ast.FuncDeclAST(self, p[1], p[2], p[4], p[6], p[7]) 380 381 # Enum fields 382 def p_type_enums__list(self, p): 383 "type_enums : type_enum type_enums" 384 p[0] = [ p[1] ] + p[2] 385 386 def p_type_enums__empty(self, p): 387 "type_enums : empty" 388 p[0] = [] 389 390 def p_type_enum(self, p): 391 "type_enum : ident pairs SEMI" 392 p[0] = ast.TypeFieldEnumAST(self, p[1], p[2]) 393 394 # States 395 def p_type_states__list(self, p): 396 "type_states : type_state type_states" 397 p[0] = [ p[1] ] + p[2] 398 399 def p_type_states__empty(self, p): 400 "type_states : empty" 401 p[0] = [] 402 403 def p_type_state(self, p): 404 "type_state : ident ',' enumeration pairs SEMI" 405 p[0] = ast.TypeFieldStateAST(self, p[1], p[3], p[4]) 406 407 # Formal Param 408 def p_params__many(self, p): 409 "params : param ',' params" 410 p[0] = [ p[1] ] + p[3] 411 412 def p_params__one(self, p): 413 "params : param" 414 p[0] = [ p[1] ] 415 416 def p_params__none(self, p): 417 "params : empty" 418 p[0] = [] 419 420 def p_param(self, p): 421 "param : type ident" 422 p[0] = ast.FormalParamAST(self, p[1], p[2]) 423 424 def p_param__pointer(self, p): 425 "param : type STAR ident" 426 p[0] = ast.FormalParamAST(self, p[1], p[3], None, True) 427 428 def p_param__pointer_default(self, p): 429 "param : type STAR ident '=' STRING" 430 p[0] = ast.FormalParamAST(self, p[1], p[3], p[5], True) 431 432 def p_param__default_number(self, p): 433 "param : type ident '=' NUMBER" 434 p[0] = ast.FormalParamAST(self, p[1], p[2], p[4]) 435 436 def p_param__default_bool(self, p): 437 "param : type ident '=' LIT_BOOL" 438 p[0] = ast.FormalParamAST(self, p[1], p[2], p[4]) 439 440 def p_param__default_string(self, p): 441 "param : type ident '=' STRING" 442 p[0] = ast.FormalParamAST(self, p[1], p[2], p[4]) 443 444 # Type 445 def p_types__multiple(self, p): 446 "types : type ',' types" 447 p[0] = [ p[1] ] + p[3] 448 449 def p_types__one(self, p): 450 "types : type" 451 p[0] = [ p[1] ] 452 453 def p_types__empty(self, p): 454 "types : empty" 455 p[0] = [] 456 457 def p_typestr__multi(self, p): 458 "typestr : typestr DOUBLE_COLON ident" 459 p[0] = '%s::%s' % (p[1], p[3]) 460 461 def p_typestr__single(self, p): 462 "typestr : ident" 463 p[0] = p[1] 464 465 def p_type__one(self, p): 466 "type : typestr" 467 p[0] = ast.TypeAST(self, p[1]) 468 469 def p_void(self, p): 470 "void : VOID" 471 p[0] = ast.TypeAST(self, p[1]) 472 473 # Idents and lists 474 def p_idents__braced(self, p): 475 "idents : '{' identx '}'" 476 p[0] = p[2] 477 478 def p_idents__bare(self, p): 479 "idents : ident" 480 p[0] = [ p[1] ] 481 482 def p_identx__multiple_1(self, p): 483 """identx : ident SEMI identx 484 | ident ',' identx""" 485 p[0] = [ p[1] ] + p[3] 486 487 def p_identx__multiple_2(self, p): 488 "identx : ident identx" 489 p[0] = [ p[1] ] + p[2] 490 491 def p_identx__single(self, p): 492 "identx : empty" 493 p[0] = [ ] 494 495 def p_ident(self, p): 496 "ident : IDENT" 497 p[0] = p[1] 498 499 # Pair and pair lists 500 def p_pairs__list(self, p): 501 "pairs : ',' pairsx" 502 p[0] = p[2] 503 504 def p_pairs__empty(self, p): 505 "pairs : empty" 506 p[0] = ast.PairListAST(self) 507 508 def p_pairsx__many(self, p): 509 "pairsx : pair ',' pairsx" 510 p[0] = p[3] 511 p[0].addPair(p[1]) 512 513 def p_pairsx__one(self, p): 514 "pairsx : pair" 515 p[0] = ast.PairListAST(self) 516 p[0].addPair(p[1]) 517 518 def p_pair__assign(self, p): 519 """pair : ident '=' STRING 520 | ident '=' ident 521 | ident '=' NUMBER""" 522 p[0] = ast.PairAST(self, p[1], p[3]) 523 524 def p_pair__literal(self, p): 525 "pair : STRING" 526 p[0] = ast.PairAST(self, "short", p[1]) 527 528 # Below are the rules for action descriptions 529 def p_statements__inner(self, p): 530 "statements : '{' statements_inner '}'" 531 p[0] = ast.StatementListAST(self, p[2]) 532 533 def p_statements__none(self, p): 534 "statements : '{' '}'" 535 p[0] = ast.StatementListAST(self, []) 536 537 def p_statements_inner__many(self, p): 538 "statements_inner : statement statements_inner" 539 p[0] = [ p[1] ] + p[2] 540 541 def p_statements_inner__one(self, p): 542 "statements_inner : statement" 543 p[0] = [ p[1] ] 544 545 def p_exprs__multiple(self, p): 546 "exprs : expr ',' exprs" 547 p[0] = [ p[1] ] + p[3] 548 549 def p_exprs__one(self, p): 550 "exprs : expr" 551 p[0] = [ p[1] ] 552 553 def p_exprs__empty(self, p): 554 "exprs : empty""" 555 p[0] = [] 556 557 def p_statement__expression(self, p): 558 "statement : expr SEMI" 559 p[0] = ast.ExprStatementAST(self, p[1]) 560 561 def p_statement__assign(self, p): 562 "statement : expr ASSIGN expr SEMI" 563 p[0] = ast.AssignStatementAST(self, p[1], p[3]) 564 565 def p_statement__enqueue(self, p): 566 "statement : ENQUEUE '(' var ',' type ')' statements" 567 p[0] = ast.EnqueueStatementAST(self, p[3], p[5], None, p[7]) 568 569 def p_statement__enqueue_latency(self, p): 570 "statement : ENQUEUE '(' var ',' type ',' expr ')' statements" 571 p[0] = ast.EnqueueStatementAST(self, p[3], p[5], p[7], p[9]) 572 573 def p_statement__stall_and_wait(self, p): 574 "statement : STALL_AND_WAIT '(' var ',' var ')' SEMI" 575 p[0] = ast.StallAndWaitStatementAST(self, p[3], p[5]) 576 577 def p_statement__peek(self, p): 578 "statement : PEEK '(' var ',' type pairs ')' statements" 579 p[0] = ast.PeekStatementAST(self, p[3], p[5], p[6], p[8], "peek") 580 581 def p_statement__check_allocate(self, p): 582 "statement : CHECK_ALLOCATE '(' var ')' SEMI" 583 p[0] = ast.CheckAllocateStatementAST(self, p[3]) 584 585 def p_statement__check_stop(self, p): 586 "statement : CHECK_STOP_SLOTS '(' var ',' STRING ',' STRING ')' SEMI" 587 p[0] = ast.CheckStopStatementAST(self, p[3], p[5], p[7]) 588 589 def p_statement__return(self, p): 590 "statement : RETURN expr SEMI" 591 p[0] = ast.ReturnStatementAST(self, p[2]) 592 593 def p_statement__if(self, p): 594 "statement : if_statement" 595 p[0] = p[1] 596 597 def p_if_statement__if(self, p): 598 "if_statement : IF '(' expr ')' statements" 599 p[0] = ast.IfStatementAST(self, p[3], p[5], None) 600 601 def p_if_statement__if_else(self, p): 602 "if_statement : IF '(' expr ')' statements ELSE statements" 603 p[0] = ast.IfStatementAST(self, p[3], p[5], p[7]) 604 605 def p_statement__if_else_if(self, p): 606 "if_statement : IF '(' expr ')' statements ELSE if_statement" 607 p[0] = ast.IfStatementAST(self, p[3], p[5], 608 ast.StatementListAST(self, p[7])) 609 610 def p_expr__static_cast(self, p): 611 "aexpr : STATIC_CAST '(' type ',' expr ')'" 612 p[0] = ast.StaticCastAST(self, p[3], "ref", p[5]) 613 614 def p_expr__static_cast_ptr(self, p): 615 "aexpr : STATIC_CAST '(' type ',' STRING ',' expr ')'" 616 p[0] = ast.StaticCastAST(self, p[3], p[5], p[7]) 617 618 def p_expr__var(self, p): 619 "aexpr : var" 620 p[0] = p[1] 621 622 def p_expr__localvar(self, p): 623 "aexpr : type ident" 624 p[0] = ast.LocalVariableAST(self, p[1], p[2]) 625 626 def p_expr__literal(self, p): 627 "aexpr : literal" 628 p[0] = p[1] 629 630 def p_expr__enumeration(self, p): 631 "aexpr : enumeration" 632 p[0] = p[1] 633 634 def p_expr__func_call(self, p): 635 "aexpr : ident '(' exprs ')'" 636 p[0] = ast.FuncCallExprAST(self, p[1], p[3]) 637 638 def p_expr__new(self, p): 639 "aexpr : NEW type" 640 p[0] = ast.NewExprAST(self, p[2]) 641 642 def p_expr__null(self, p): 643 "aexpr : OOD" 644 p[0] = ast.OodAST(self) 645 646 def p_expr__member(self, p): 647 "aexpr : aexpr DOT ident" 648 p[0] = ast.MemberExprAST(self, p[1], p[3]) 649 650 def p_expr__member_method_call(self, p): 651 "aexpr : aexpr DOT ident '(' exprs ')'" 652 p[0] = ast.MemberMethodCallExprAST(self, p[1], p[3], p[5]) 653 654 def p_expr__member_method_call_lookup(self, p): 655 "aexpr : aexpr '[' exprs ']'" 656 p[0] = ast.MemberMethodCallExprAST(self, p[1], "lookup", p[3]) 657 658 def p_expr__class_method_call(self, p): 659 "aexpr : type DOUBLE_COLON ident '(' exprs ')'" 660 p[0] = ast.ClassMethodCallExprAST(self, p[1], p[3], p[5]) 661 662 def p_expr__aexpr(self, p): 663 "expr : aexpr" 664 p[0] = p[1] 665 666 def p_expr__binary_op(self, p): 667 """expr : expr STAR expr 668 | expr SLASH expr 669 | expr PLUS expr 670 | expr DASH expr 671 | expr LT expr 672 | expr GT expr 673 | expr LE expr 674 | expr GE expr 675 | expr EQ expr 676 | expr NE expr 677 | expr AND expr 678 | expr OR expr 679 | expr RIGHTSHIFT expr 680 | expr LEFTSHIFT expr""" 681 p[0] = ast.InfixOperatorExprAST(self, p[1], p[2], p[3]) 682 683 # FIXME - unary not 684 def p_expr__unary_op(self, p): 685 """expr : NOT expr 686 | INCR expr 687 | DECR expr 688 | DASH expr %prec UMINUS""" 689 p[0] = ast.PrefixOperatorExprAST(self, p[1], p[2]) 690 691 def p_expr__parens(self, p): 692 "aexpr : '(' expr ')'" 693 p[0] = p[2] 694 695 def p_expr__is_valid_ptr(self, p): 696 "aexpr : IS_VALID '(' var ')'" 697 p[0] = ast.IsValidPtrExprAST(self, p[3], True) 698 699 def p_expr__is_invalid_ptr(self, p): 700 "aexpr : IS_INVALID '(' var ')'" 701 p[0] = ast.IsValidPtrExprAST(self, p[3], False) 702 703 def p_literal__string(self, p): 704 "literal : STRING" 705 p[0] = ast.LiteralExprAST(self, p[1], "std::string") 706 707 def p_literal__number(self, p): 708 "literal : NUMBER" 709 p[0] = ast.LiteralExprAST(self, p[1], "int") 710 711 def p_literal__float(self, p): 712 "literal : FLOATNUMBER" 713 p[0] = ast.LiteralExprAST(self, p[1], "int") 714 715 def p_literal__bool(self, p): 716 "literal : LIT_BOOL" 717 p[0] = ast.LiteralExprAST(self, p[1], "bool") 718 719 def p_enumeration(self, p): 720 "enumeration : ident ':' ident" 721 p[0] = ast.EnumExprAST(self, ast.TypeAST(self, p[1]), p[3]) 722 723 def p_var(self, p): 724 "var : ident" 725 p[0] = ast.VarExprAST(self, p[1]) 726