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