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