File indexing completed on 2024-04-21 15:33:21
0001 # -*- coding: utf-8 -*- 0002 # Copyright 2007-8 Jim Bublitz <jbublitz@nwinternet.com> 0003 # Copyright 2009 Simon Edwards <simon@simonzone.com> 0004 # 0005 # This program is free software; you can redistribute it and/or modify 0006 # it under the terms of the GNU General Public License as published by 0007 # the Free Software Foundation; either version 2 of the License, or 0008 # (at your option) any later version. 0009 # 0010 # This program is distributed in the hope that it will be useful, 0011 # but WITHOUT ANY WARRANTY; without even the implied warranty of 0012 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 0013 # GNU General Public License for more details. 0014 # 0015 # You should have received a copy of the GNU General Public License 0016 # along with this program; if not, write to the 0017 # Free Software Foundation, Inc., 0018 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 0019 0020 import sys 0021 import re 0022 from .sealed import sealed 0023 import ply.yacc as yacc 0024 import kbindinggenerator.cpplexer as cpplexer 0025 import kbindinggenerator.pplexer as pplexer 0026 import inspect 0027 0028 def joinp(p, startindex, string=" "): 0029 tmplist = [] 0030 i = startindex 0031 while i < len(p): 0032 tmplist.append(p[i]) 0033 i += 1 0034 return string.join(tmplist) 0035 0036 class CppParser(object): 0037 """Parser for C++ header files.""" 0038 0039 @sealed 0040 def __init__(self): 0041 """Instantiate a new C++ parser.""" 0042 self._bareMacros = [] 0043 self._macros = [] 0044 self._preprocessorValues = {} 0045 self._preprocessorSubstitutionMacros = [] 0046 0047 self.lexer = cpplexer.CppLexer() 0048 self.lexer.begin('variable') 0049 self._resetState() 0050 self.tokens = cpplexer.tokens 0051 yacc.yacc(module = self, tabmodule = "cppParserTab") 0052 self._parse = yacc.parse 0053 0054 def _resetState(self): 0055 self.filename = None 0056 self._scopeStack = [] 0057 self.scope = None 0058 self.access = "public" 0059 self._accessStack = [] 0060 self.currentFunction = None 0061 self.currentClass = None 0062 self.exprElement = None 0063 self.inTypedef = False 0064 0065 self.arguments = [] 0066 self.templateParams = [] 0067 self.storage = '' 0068 self.inline = False 0069 self.template = None 0070 self.exprElements = [] 0071 self.symbolData = None 0072 self.scope = None 0073 0074 @property 0075 def bareMacros(self): 0076 """List of bare macro names. 0077 0078 A bare macro is C++ macro which takes no arguments. Any bare macros 0079 are parsed and recorded in a `ScopedMacro` object.""" 0080 return self._bareMacros 0081 @bareMacros.setter 0082 def bareMacros(self,bareMacroList): 0083 self._bareMacros = bareMacroList 0084 self.lexer.lexmodule.setBareMacros(bareMacroList) 0085 0086 @property 0087 def macros(self): 0088 """List of macro names. 0089 0090 Any macros are parsed and recorded in a `ScopedMacro` object along 0091 with their arguments.""" 0092 return self._macros 0093 @macros.setter 0094 def macros(self,macroList): 0095 self.lexer.lexmodule.setMacros(macroList) 0096 self._macros = macroList 0097 0098 @property 0099 def preprocessorValues(self): 0100 """List of symbols and values to be used by the preprocessor. 0101 0102 This is a dict mapping string values to values which can be used when 0103 evaluating preprocessor expressions.""" 0104 return self._preprocessorValues 0105 @preprocessorValues.setter 0106 def preprocessorValues(self,valueList): 0107 self._preprocessorValues = valueList 0108 0109 @property 0110 def preprocessorSubstitutionMacros(self): 0111 """Macros to be substituated by the C++ preprocessor. 0112 0113 This is a list of tuples. The first value is a string or regular 0114 expression object which is used to match macros in the text, and 0115 the second value is the substituation text.""" 0116 return self._preprocessorSubstitutionMacros 0117 @preprocessorSubstitutionMacros.setter 0118 def preprocessorSubstitutionMacros(self,macroList): 0119 self._preprocessorSubstitutionMacros = macroList 0120 0121 def parse(self, symbolData, text, filename=None, debugLevel = 0): 0122 """Parse the given C++ header text 0123 0124 Keyword arguments: 0125 symbolData -- cppsymboldata.SymbolData instance. The parsed entities are added to this instance. 0126 text -- String, the text to parse. 0127 filename -- The filename belonging to the given text. This is used for error messages and can be None. 0128 debugLevel -- Turns on debug messages from the lexer and parser. 0, the default, means no debug. 2 lists the 0129 tokens as they arrive. 0130 0131 Returns: 0132 -- Newly created `Scope` object containing the parsed data. 0133 0134 All of the top level things in the given text are parsed and placed inside the top scope inside the 0135 symbolData. 0136 0137 If a parse error is encountered, the whole program is exited. Sorry. 0138 """ 0139 self._resetState() 0140 self.filename = filename 0141 0142 self.symbolData = symbolData 0143 self.scope = self.symbolData.newScope() 0144 0145 chewedText = pplexer.preprocess(text, self._preprocessorValues, self.__compileMacros(self._preprocessorSubstitutionMacros)) 0146 0147 self.lexer.input(chewedText) 0148 self.lexer.lineno = 1 0149 self.lexer.lexpos = 0 0150 0151 result = self._parse(debug = debugLevel, lexer = self.lexer) 0152 return self.scope 0153 0154 def __compileMacros(self, macroList): 0155 # Convert the list of macros to regular expressions. Macro which are 0156 # already regexs don't need to changed. Bare string macros and their 0157 # substituation strings are treated as straight string substituations. 0158 compiledMacros = [] 0159 for item in macroList: 0160 if not isinstance(item[0],str): 0161 compiledMacros.append(item) 0162 else: 0163 compiledMacros.append( (re.compile(item[0]), re.escape(item[1])) ) 0164 return compiledMacros 0165 0166 def _pushScope(self, newScope): 0167 self._scopeStack.append(self.scope) 0168 self.scope = newScope 0169 #print("\n_pushScope") 0170 #self._dumpScopeStack() 0171 0172 def _popScope(self): 0173 #print("\n_popScope") 0174 self.scope = self._scopeStack.pop() 0175 #self._dumpScopeStack() 0176 0177 def _dumpScopeStack(self): 0178 print("Scope stack: [" + (", ".join(repr(s) for s in self._scopeStack)) + "]") 0179 for s in inspect.stack()[:4]: 0180 print(repr(s)) 0181 0182 def _pushAccess(self, newAccess): 0183 self._accessStack.append(self.access) 0184 self.access = newAccess 0185 0186 def _popAccess(self): 0187 self.access = self._accessStack.pop() 0188 0189 def object_id_list (self, id_list, obj, objType = None): 0190 idList = id_list.split (',') 0191 if self.inTypedef: 0192 self.stateInfo.currentObject ().name = idList [0] 0193 for id in idList [1:]: 0194 originalObj = self.stateInfo.popObject () 0195 if obj == 'class': 0196 newObj = self.classObject (id, objType) 0197 elif obj == 'enum': 0198 newObj = self.enumObject (id) 0199 newObj.enumerators = originalObj.enumerators 0200 else: 0201 for id in idList: 0202 self.variableObject (id, self.stateInfo.currentObject ().name) 0203 0204 def commentObject(self,value): 0205 comment = self.symbolData.Comment(self.scope, self.filename, self.lexer.lineno) 0206 comment.setValue(value) 0207 return comment 0208 0209 def classObject (self, name, type_): 0210 class_ = self.symbolData.CppClass(self.scope, name, self.filename, self.lexer.lineno) 0211 self.currentClass = class_ 0212 self._pushScope(class_) 0213 class_.setAccess(self.access) 0214 0215 def enumObject (self, name): 0216 enum = self.symbolData.Enum(None, name, self.filename, self.lexer.lineno) 0217 enum.setAccess(self.access) 0218 return enum 0219 0220 def typedefObject(self, typeName, newName): 0221 tdObj = self.symbolData.Typedef(self.scope, newName, self.filename, self.lexer.lineno) 0222 tdObj.setArgumentType(typeName) 0223 # if typeName.startswith('QFlags<'): 0224 # tdObj.template = Template('QFlags', typeName [7:-1]) 0225 # else: 0226 # tdObj.template = self.template 0227 # self.template = None 0228 # self._pushScope(tdObj) 0229 return tdObj 0230 0231 def bareMacro(self,name): 0232 macro = self.symbolData.ScopedMacro(self.scope, name, self.filename, self.lexer.lineno) 0233 return macro 0234 0235 def argument(self, argumentType, argumentName = None, argumentValue = None): 0236 self.arguments.append ((argumentType, argumentName, argumentValue, self.template, self.exprElements)) 0237 self.template = None 0238 self.exprElements = [] 0239 return self.arguments 0240 0241 def argumentList(self): 0242 instanceList = [] 0243 for argTuple in self.arguments: 0244 vtype, name, init, template, exprElements = argTuple 0245 instanceList.append(self.symbolData.Argument(vtype, name, init, template)) 0246 return instanceList 0247 0248 def variableObject(self, name, vtype, init = None): 0249 vObj = self.symbolData.Variable(self.scope, name, self.filename, self.lexer.lineno) 0250 vObj.setArgument(self.symbolData.Argument(vtype, name, init, None, self.template)) 0251 vObj.setStorage(self.storage) 0252 vObj.setAccess(self.access) 0253 0254 self.storage = None 0255 self.template = None 0256 return vObj 0257 0258 def functionObject(self, name, returns): 0259 if returns=='ctor': 0260 functionObj = self.symbolData.Constructor(self.scope, name, self.filename, self.lexer.lineno) 0261 elif returns=='dtor': 0262 functionObj = self.symbolData.Destructor(self.scope, name, self.filename, self.lexer.lineno) 0263 else: 0264 functionObj = self.symbolData.Function(self.scope, name, self.filename, self.lexer.lineno) 0265 returnArg = self.symbolData.Argument(returns) 0266 functionObj.setReturn(returnArg) 0267 functionObj.setAccess(self.access) 0268 0269 functionObj.setTemplate(self.template) 0270 self.template = None 0271 0272 self.exprElements = [] 0273 0274 functionObj.setStorage(self.storage) 0275 self.storage = None 0276 0277 #functionObj.templateParams = self.stateInfo.inTemplate 0278 #self.stateInfo.inTemplate = [] 0279 0280 self.currentFunction = functionObj 0281 0282 if self.lexer.lexstate not in ['stmt', 'operator']: 0283 self.lexer.begin ('function') 0284 return functionObj 0285 0286 precedence = (('right','UMINUS'), ) 0287 #precedence = (('left','+','-'), ('left','*','/'), ('right','UMINUS'), ) 0288 0289 # start 0290 def p_declarations (self, p): 0291 """declarations : member 0292 | member_list member""" 0293 pass 0294 0295 def p_member (self, p): 0296 """member : namespace_decl 0297 | class_decl 0298 | enum_decl 0299 | typedef_decl 0300 | typedef_enum_decl 0301 | function_decl 0302 | variable_decl 0303 | bare_macro 0304 | skip_macro 0305 | doccomment 0306 | SEMI""" 0307 self.lexer.lexstate = 'variable' 0308 self.arguments = [] 0309 self.template = None 0310 self.exprElement = None 0311 0312 def p_member2 (self, p): 0313 """member : template_decl""" 0314 self.lexer.lexstate = 'variable' 0315 self.template = p[1] 0316 self.arguments = [] 0317 self.exprElement = None 0318 0319 def p_member_list (self, p): 0320 """member_list : member 0321 | member_list member""" 0322 pass 0323 0324 def p_namespace_decl0 (self, p): 0325 'namespace_decl : namespace_name LBRACE member_list RBRACE' 0326 self._popScope() 0327 0328 def p_namespace_decl1 (self, p): 0329 'namespace_decl : namespace_name LBRACE RBRACE' 0330 self._popScope() 0331 0332 def p_namespace_decl2 (self, p): 0333 'namespace_decl : namespace LBRACE member_list RBRACE' 0334 pass 0335 0336 def p_namespace_name (self, p): 0337 'namespace_name : namespace ID' 0338 name = p[2] 0339 namespace = self.symbolData.Namespace(self.scope, name, self.filename, self.lexer.lineno) 0340 self._pushScope(namespace) 0341 0342 def p_empty (self, p): 0343 'empty :' 0344 pass 0345 0346 def p_decl_end (self, p): 0347 """decl_end : SEMI 0348 | inline_code""" 0349 pass 0350 0351 def p_class_decl0 (self, p): 0352 """class_decl : class_header class_member_list RBRACE decl_end 0353 | class_header RBRACE decl_end""" 0354 #name, obj = self.stateInfo.popClass () 0355 self._popAccess() 0356 self._popScope() 0357 #if not obj.opaque: 0358 # self.symbolData.objectList.append (EndClassMarker (name, self.lexer.lineno, self.stateInfo)) 0359 def p_class_declopaque(self,p): 0360 """class_decl : opaque_class""" 0361 self._popScope() 0362 0363 def p_class_decl1 (self, p): 0364 'class_decl : class_header class_member_list RBRACE id_list decl_end' 0365 if p [1] in ['class', 'struct', 'union']: 0366 self.object_id_list (p [4], p [1]) 0367 else: 0368 self.object_id_list (p [4], 'class') 0369 name, obj = self.stateInfo.popClass () 0370 self._popAccess() 0371 self._popScope() 0372 0373 def p_class_member (self, p): 0374 """class_member : class_decl 0375 | enum_decl 0376 | typedef_decl 0377 | typedef_enum_decl 0378 | access_specifier 0379 | function_decl 0380 | variable_decl 0381 | doccomment 0382 | bare_macro 0383 | skip_macro 0384 | SEMI""" 0385 self.lexer.lexstate = 'variable' 0386 self.arguments = [] 0387 self.template = None 0388 self.exprElement = None 0389 0390 def p_class_member2 (self, p): 0391 """class_member : template_decl""" 0392 self.lexer.lexstate = 'variable' 0393 self.arguments = [] 0394 self.template = p[1] 0395 self.exprElement = None 0396 0397 def p_access_specifier (self, p): 0398 """access_specifier : public COLON 0399 | public slots COLON 0400 | protected COLON 0401 | protected slots COLON 0402 | private COLON 0403 | private slots COLON 0404 | signals COLON 0405 | slots COLON""" 0406 self.access = p[1] 0407 0408 def p_base_access_specifier (self, p): 0409 """base_access_specifier : public 0410 | protected 0411 | private""" 0412 pass 0413 0414 def p_class_member_list (self, p): 0415 """class_member_list : class_member 0416 | class_member_list class_member""" 0417 pass 0418 0419 0420 def p_class_header0 (self, p): 0421 """class_header : class_name LBRACE 0422 | class_name COLON base_list LBRACE 0423 | class_from_typedef""" 0424 p[0] = p[1] 0425 self._pushAccess('private') 0426 0427 def p_class_header1 (self, p): 0428 """class_header : union LBRACE 0429 | struct LBRACE""" 0430 self.classObject('anonymous', p[1]) 0431 self._pushAccess('private') 0432 0433 def p_class_name (self, p): 0434 """class_name : class ID 0435 | struct ID 0436 | union ID 0437 | class template_type 0438 | struct template_type""" 0439 self.classObject(p[2], p[1]) 0440 0441 def p_class_name1 (self, p): 0442 """class_name : class BAREMACRO ID 0443 | struct BAREMACRO ID 0444 | union BAREMACRO ID 0445 | class BAREMACRO template_type 0446 | struct BAREMACRO template_type""" 0447 self.classObject(p[3], p[1]) 0448 self.currentClass.addMacro(self.symbolData.Macro(p[2])) 0449 0450 def p_opaque_class (self, p): 0451 'opaque_class : class_name SEMI' 0452 self.currentClass.setOpaque(True) 0453 0454 def p_base_list_element0 (self, p): 0455 """base_list_element : base_access_specifier qualified_id 0456 | base_access_specifier template_type""" 0457 self.currentClass.addBase(p[2]) 0458 0459 def p_base_list_element1 (self, p): 0460 """base_list_element : virtual base_access_specifier qualified_id 0461 | virtual base_access_specifier template_type""" 0462 self.currentClass.addBase(p[3]) 0463 0464 def p_base_list_element2 (self, p): 0465 'base_list_element : qualified_id' 0466 self.currentClass.addBase(p[1]) 0467 0468 def p_base_list (self, p): 0469 """base_list : base_list_element 0470 | base_list COMMA base_list_element""" 0471 pass 0472 0473 def p_enum_decl0 (self, p): 0474 """enum_decl : enum_statement SEMI""" 0475 self.scope.append(p[1]) 0476 0477 def p_enum_decl1 (self, p): 0478 """enum_decl : enum_statement id_list SEMI""" 0479 self.scope.append(p[1]) 0480 #self.lexer.begin('variable') 0481 0482 def p_enum_statement0 (self, p): 0483 """enum_statement : enum_name enumerator_list RBRACE""" 0484 for enum in p[2]: 0485 p[1].appendEnumerator(enum) 0486 #self._popScope() 0487 self.lexer.begin ('variable') 0488 p[0] = p[1] 0489 0490 def p_enum_statement1 (self, p): 0491 """enum_statement : enum_name RBRACE""" 0492 p[0] = p[1] 0493 self.lexer.begin ('variable') 0494 0495 def p_enum_name0 (self, p): 0496 """enum_name : enum ID LBRACE 0497 | enum LBRACE""" 0498 if p[2] != "{": 0499 name = p[2] 0500 else: 0501 name = None 0502 p[0] = self.enumObject(name) 0503 0504 def p_typedef_enum (self, p): 0505 """typedef_enum_decl : typedef enum_statement SEMI 0506 | typedef enum_statement id_list SEMI""" 0507 name = p[2].name() 0508 if len(p)==5: 0509 name = p[3] 0510 self.symbolData.EnumTypedef(self.scope, name, p[2], self.filename, self.lexer.lineno) 0511 0512 def p_enumerator0 (self, p): 0513 """enumerator : ID""" 0514 enumerator = self.symbolData.Enumerator(p[1], None) 0515 p[0] = enumerator 0516 0517 def p_enumerator1 (self, p): 0518 """enumerator : ID EQUALS expression""" 0519 enumerator = self.symbolData.Enumerator(p[1], p[3]) 0520 p[0] = enumerator 0521 0522 def p_enumerator2 (self, p): 0523 """enumerator : DOC ID""" 0524 enumerator = self.symbolData.Enumerator(p[2], None) 0525 #enumerator.setDoc(p[1]) 0526 p[0] = enumerator 0527 0528 def p_enumerator3 (self, p): 0529 """enumerator : DOC ID EQUALS expression""" 0530 enumerator = self.symbolData.Enumerator(p[2], p[4]) 0531 #enumerator.setDoc(p[1]) 0532 p[0] = enumerator 0533 0534 def p_enumerator4 (self, p): 0535 """enumerator : ID EQUALS expression enum_doc""" 0536 enumerator = self.symbolData.Enumerator(p[1], p[3]) 0537 #enumerator.setDoc(p[4]) 0538 p[0] = enumerator 0539 0540 def p_enumerator5 (self, p): 0541 """enumerator : ID enum_doc""" 0542 enumerator = self.symbolData.Enumerator(p[1], None) 0543 #enumerator.setDoc(p[2]) 0544 p[0] = enumerator 0545 0546 def p_enumerator_list0 (self, p): 0547 """enumerator_list : enumerator""" 0548 p[0] = [p[1]] 0549 0550 def p_enumerator_list1 (self, p): 0551 """enumerator_list : enumerator_list enum_delim enumerator""" 0552 p[1].append(p[3]) 0553 p[0] = p[1] 0554 0555 def p_enumerator_list2 (self, p): 0556 """enumerator_list : enumerator_list enum_doc""" 0557 p[0] = p[1] 0558 0559 def p_enum_delim0 (self, p): 0560 """enum_delim : COMMA""" 0561 p[0] = (None,None) # (DOC,UPDOC) 0562 0563 def p_enum_delim1 (self, p): 0564 """enum_delim : COMMA enum_doc""" 0565 p[0] = (None,None) # (DOC,UPDOC) 0566 0567 def p_enum_doc(self, p): 0568 """enum_doc : enum_doc DOC 0569 | enum_doc UPDOC 0570 | DOC 0571 | UPDOC""" 0572 pass 0573 0574 def p_id_list_element0 (self, p): 0575 'id_list_element : ID' 0576 p[0] = p[1] 0577 0578 def p_id_list_element1 (self, p): 0579 """id_list_element : ASTERISK ID 0580 | AMPERSAND ID""" 0581 p[0] = p[1] 0582 0583 def p_id_list (self, p): 0584 """id_list : id_list_element 0585 | id_list COMMA id_list_element""" 0586 p[0] = joinp(p, 1, "") 0587 0588 def p_qualified_id (self, p): 0589 """qualified_id : ID 0590 | nested_name_specifier""" 0591 p [0] = p [1] 0592 0593 def p_nested_name_specifier0 (self, p): 0594 """nested_name_specifier : ID COLON2 ID 0595 | nested_name_specifier COLON2 ID 0596 | template_type COLON2 ID""" 0597 p[0] = joinp(p, 1, "") 0598 0599 def p_nested_name_specifier1 (self, p): 0600 """nested_name_specifier : ID COLON2 TILDE ID 0601 | nested_name_specifier COLON2 TILDE ID 0602 | template_type COLON2 TILDE ID""" 0603 p[0] = joinp(p, 1, "") 0604 0605 def p_nested_name_specifier2 (self, p): 0606 'nested_name_specifier : COLON2 ID' 0607 p [0] = p [2] 0608 0609 def p_template_type (self, p): 0610 """template_type : qualified_id LT type_specifier_list GT 0611 | qualified_id LT static_cast_expression GT""" 0612 p[0] = joinp(p, 1, "") 0613 0614 def p_elaborated_type (self, p): 0615 """elaborated_type : enum qualified_id 0616 | class qualified_id 0617 | struct qualified_id 0618 | union qualified_id 0619 | typename qualified_id""" 0620 p [0] = p [2] 0621 0622 def p_type_specifier_base (self, p): 0623 """type_specifier_base : qualified_id 0624 | template_type 0625 | elaborated_type 0626 | int 0627 | unsigned int 0628 | signed int 0629 | char 0630 | unsigned char 0631 | signed char 0632 | float 0633 | double 0634 | long 0635 | long int 0636 | unsigned long 0637 | unsigned long int 0638 | long unsigned int 0639 | signed long 0640 | signed long int 0641 | long long 0642 | unsigned long long 0643 | signed long long 0644 | signed long long int 0645 | short 0646 | unsigned short 0647 | signed short 0648 | short int 0649 | unsigned short int 0650 | signed short int 0651 | unsigned 0652 | signed 0653 | bool 0654 | void 0655 | wchar_t""" 0656 p [0] = joinp(p,1) 0657 0658 def p_type_specifier0 (self, p): 0659 'type_specifier : type_specifier_base ' 0660 p [0] = p [1] 0661 0662 def p_type_specifier1 (self, p): 0663 'type_specifier : CVQUAL type_specifier_base' 0664 p [0] = '%s %s' % (p [1], p[2]) 0665 0666 def p_type_specifier2 (self, p): 0667 'type_specifier : type_specifier_base type_decorator' 0668 p [0] = '%s%s' % (p [1], p[2]) 0669 0670 def p_type_specifier3 (self, p): 0671 'type_specifier : CVQUAL type_specifier_base type_decorator' 0672 p [0] = '%s %s%s' % (p [1], p[2], p[3]) 0673 0674 def p_type_specifier4 (self, p): 0675 'type_specifier : type_specifier_base CVQUAL type_decorator' 0676 p [0] = '%s %s%s' % (p [2], p[1], p[3]) 0677 0678 def p_type_specifier5 (self, p): 0679 'type_specifier : type_specifier_base CVQUAL' 0680 p [0] = '%s %s' % (p [2], p[1]) 0681 0682 def p_type_decorator (self, p): 0683 """type_decorator : ASTERISK 0684 | AMPERSAND 0685 | ASTERISK CVQUAL 0686 | ASTERISK AMPERSAND 0687 | ASTERISK ASTERISK 0688 | ASTERISK ASTERISK ASTERISK 0689 | ARRAYOP""" 0690 p [0] = joinp(p, 1, "") 0691 0692 0693 def p_type_specifier_list (self, p): 0694 """type_specifier_list : type_specifier 0695 | type_specifier_list COMMA type_specifier""" 0696 p [0] = joinp(p, 1, "") 0697 0698 def p_typedef_decl (self, p): 0699 """typedef_decl : typedef_simple SEMI 0700 | typedef_elaborated SEMI 0701 | typedef_function_ptr SEMI""" 0702 self._popScope() 0703 0704 def p_typedef_simple0 (self, p): 0705 'typedef_simple : typedef type_specifier ID' 0706 tdObj = self.typedefObject(p[2], p[3]) 0707 self._pushScope(tdObj) 0708 self.inTypedef = True 0709 0710 def p_typedef_simple1 (self, p): 0711 'typedef_simple : typedef type_specifier ID ARRAYOP' 0712 tdObj = self.typedefObject('%s*' % p [2], p [3]) 0713 self._pushScope(tdObj) 0714 self.inTypedef = True 0715 0716 def p_typedef_elaborated (self, p): 0717 """typedef_elaborated : typedef class qualified_id ID 0718 | typedef struct qualified_id ID 0719 | typedef union qualified_id ID 0720 | typedef enum qualified_id ID""" 0721 tdObj = self.typedefObject(p[3], p[4]) 0722 self._pushScope(tdObj) 0723 self.inTypedef = True 0724 0725 def p_class_from_typedef0 (self, p): 0726 """class_from_typedef : typedef class ID LBRACE 0727 | typedef struct ID LBRACE 0728 | typedef union ID LBRACE""" 0729 p [0] = p [2] 0730 self.classObject (p [3], p [2]) 0731 self.inTypedef = True 0732 0733 def p_class_from_typedef1 (self, p): 0734 """class_from_typedef : typedef struct LBRACE 0735 | typedef union LBRACE""" 0736 p [0] = p [2] 0737 self.classObject ('anonymous', p [2]) 0738 self.inTypedef = True 0739 0740 def p_pointer_to_function_pfx (self, p): 0741 """pointer_to_function_pfx : ASTERISK FUNCPTR 0742 | type_specifier FUNCPTR""" 0743 if p[1] == '*': 0744 p [0] = '*%s' % p[2] 0745 else: 0746 p [0] = p[1] 0747 0748 def p_pointer_to_function_name (self, p): 0749 'pointer_to_function_name : pointer_to_function_pfx ID' 0750 p [0] = "|".join ([p[1], p[2]]) 0751 0752 def p_pointer_to_function_args (self, p): 0753 """pointer_to_function_args : RPAREN LPAREN type_specifier_list 0754 | RPAREN LPAREN empty""" 0755 p [0] = p [3] 0756 0757 def p_pointer_to_function (self, p): 0758 'pointer_to_function : pointer_to_function_name pointer_to_function_args RPAREN' 0759 if p [2]: 0760 p [0] = "|".join ([p [1], p [2]]) 0761 else: 0762 p [0] = "|".join ([p [1], ""]) 0763 0764 def p_typedef_function_ptr (self, p): 0765 'typedef_function_ptr : typedef pointer_to_function' 0766 0767 ptrType, name, args = p [2].split ('|', 2) 0768 0769 fa = self.symbolData.FunctionArgument(name, ptrType, args) 0770 typedefObj = self.symbolData.FunctionPointerTypedef(self.scope, fa, self.filename, self.lexer.lineno) 0771 typedefObj.setAccess(self.access) 0772 self.inTypedef = True 0773 0774 self._pushScope(typedefObj) 0775 0776 def p_array_variable (self, p): 0777 'array_variable : ID ARRAYOP' 0778 p [0] = p[1] + " " + p[2] 0779 0780 def p_argument_specifier0 (self, p): 0781 """argument_specifier : type_specifier 0782 | ELLIPSIS""" 0783 p [0] = self.argument (p [1]) 0784 0785 def p_argument_specifier1 (self, p): 0786 """argument_specifier : type_specifier ID 0787 | type_specifier array_variable""" 0788 p [0] = self.argument (p [1], p [2]) 0789 0790 def p_argument_specifier2 (self, p): 0791 'argument_specifier : type_specifier EQUALS expression' 0792 p [0] = self.argument (p [1], None, p [3]) 0793 0794 def p_argument_specifier3 (self, p): 0795 """argument_specifier : type_specifier ID EQUALS expression 0796 | type_specifier array_variable EQUALS expression""" 0797 p [0] = self.argument (p [1], p [2], p [4]) 0798 0799 def p_argument_specifier4 (self, p): 0800 'argument_specifier : pointer_to_function' 0801 argType, name, args = p [1].split ('|', 2) 0802 p[0] = self.argument('$fp' + argType, name, args) 0803 0804 def p_argument_list0 (self, p): 0805 """argument_list : argument_specifier""" 0806 # | type_specifier""" 0807 p [0] = [p [1]] 0808 0809 def p_argument_list1 (self, p): 0810 """argument_list : argument_list COMMA argument_specifier 0811 | argument_list COMMA type_specifier""" 0812 if p [0]: 0813 p [0].append (p [3]) 0814 else: 0815 p [0] = [p [3]] 0816 0817 def p_decl_starter0 (self, p): 0818 'decl_starter : type_specifier qualified_id' 0819 p [0] = joinp(p, 1, "|") 0820 0821 def p_decl_starter1 (self, p): 0822 'decl_starter : type_specifier bare_macro qualified_id' 0823 p [0] = p[1] + "|" + p[3] 0824 0825 def p_decl_starter2 (self, p): 0826 'decl_starter : STORAGE type_specifier qualified_id' 0827 p [0] = joinp(p, 2, "|") 0828 self.storage = p [1] 0829 0830 def p_decl_starter3 (self, p): 0831 'decl_starter : STORAGE bare_macro type_specifier qualified_id' 0832 p [0] = joinp(3, "|") 0833 self.storage = p [1] 0834 0835 def p_decl_starter4 (self, p): 0836 'decl_starter : STORAGE type_specifier bare_macro qualified_id' 0837 p [0] = p[2] + "|" + p[4] 0838 self.storage = p [1] 0839 0840 def p_variable_decl0 (self, p): 0841 'variable_decl : decl_starter SEMI' 0842 vtype, name = p [1].split ('|') 0843 self.variableObject (name, vtype) 0844 0845 def p_variable_decl1 (self, p): 0846 'variable_decl : argument_specifier SEMI' 0847 vtype, name, init = p[1][0][:3] 0848 self.variableObject (name, vtype, init) 0849 0850 def p_variable_decl2 (self, p): 0851 'variable_decl : STORAGE argument_specifier SEMI' 0852 vtype, name, eqsign, init = p [2][0][:4] 0853 self.variableObject (name, vtype, init) 0854 0855 def p_variable_decl3 (self, p): 0856 'variable_decl : type_specifier id_list SEMI' 0857 vtype = p [1] 0858 names = p[2].split (',') 0859 for name in names: 0860 self.variableObject (name, vtype) 0861 0862 def p_variable_decl4 (self, p): 0863 'variable_decl : STORAGE type_specifier id_list SEMI' 0864 self.storage = p[1] 0865 vtype = p [2] 0866 names = p[3].split (',') 0867 for name in names: 0868 self.variableObject (name, vtype) 0869 0870 def p_variable_decl5 (self, p): 0871 'variable_decl : type_specifier CVQUAL ID SEMI' 0872 vObj = self.variableObject (p [3], p [1]) 0873 vObj.variable.attributes.cv = p [2] 0874 0875 def p_variable_decl6 (self, p): 0876 'variable_decl : type_specifier ID COLON ICONST SEMI' 0877 vObj = self.variableObject (p [2], p [1]) 0878 vObj.setBitfield(p[4]) 0879 0880 def p_variable_decl7 (self, p): 0881 'variable_decl : pointer_to_function SEMI' 0882 varType, name, args = p [1].split ("|", 2) 0883 varObj = self.variableObject (name, varType, None) 0884 0885 if args: 0886 varObj.functionPtr = args.split (',') 0887 else: 0888 varObj.functionPtr = [] 0889 0890 def p_function_name (self, p): 0891 'function_name : decl_starter LPAREN' 0892 returns, name = p [1].split ('|') 0893 func = self.functionObject(name, returns) 0894 func.setAccess(self.access) 0895 self.arguments = [] 0896 0897 def p_operator_pfx (self, p): 0898 'operator_pfx : type_specifier operator' 0899 p [0] = p [1] 0900 0901 def p_operator_pfx2 (self, p): 0902 'operator_pfx : type_specifier bare_macro operator' 0903 p [0] = p [1] 0904 0905 def p_operator_pfx3 (self, p): 0906 'operator_pfx : type_specifier bare_macro type_decorator operator' 0907 p [0] = p [1] 0908 0909 def p_operator_pfx4 (self, p): 0910 'operator_pfx : type_specifier ID COLON2 operator' 0911 p [0] = p[1] + " " + p[2] + p[3] 0912 0913 def p_operatorpfx5(self, p): 0914 'operator_pfx : type_specifier template_type COLON2 operator' 0915 p[0] = p[1] + " " + p[2] + p[3] 0916 0917 def p_operator_name (self, p): 0918 """operator_name : operator_pfx operator_type""" 0919 if p[1] is not None: 0920 self.functionObject ('operator' + p[2], p[1]) 0921 self.arguments = [] 0922 0923 def p_operator_type (self, p): 0924 """operator_type : PLUS LPAREN 0925 | MINUS LPAREN 0926 | ASTERISK LPAREN 0927 | SLASH LPAREN 0928 | PERCENT LPAREN 0929 | VBAR LPAREN 0930 | AMPERSAND LPAREN 0931 | LT LPAREN 0932 | LT LT LPAREN 0933 | GT LPAREN 0934 | GT GT LPAREN 0935 | LOR LPAREN 0936 | LAND LPAREN 0937 | BANG LPAREN 0938 | LE LPAREN 0939 | GE LPAREN 0940 | EQ LPAREN 0941 | EQUALS LPAREN 0942 | TIMESEQUAL LPAREN 0943 | DIVEQUAL LPAREN 0944 | MODEQUAL LPAREN 0945 | PLUSEQUAL LPAREN 0946 | MINUSEQUAL LPAREN 0947 | LSHIFTEQUAL LPAREN 0948 | GT GE LPAREN 0949 | ANDEQUAL LPAREN 0950 | OREQUAL LPAREN 0951 | XOREQUAL LPAREN 0952 | PLUSPLUS LPAREN 0953 | MINUSMINUS LPAREN 0954 | ARRAYOP LPAREN 0955 | LPAREN RPAREN LPAREN 0956 | ARROW LPAREN 0957 | NE LPAREN""" 0958 if len(p) == 3: 0959 p[0] = p[1] 0960 elif len(p) == 4: 0961 p[0] = p[1] + p[2] 0962 0963 def p_cast_operator_operator(self, p): 0964 """cast_operator_keyword : operator""" 0965 self.lexer.begin('function') 0966 0967 def p_cast_operator_name0 (self, p): 0968 'cast_operator_name : cast_operator_keyword type_specifier LPAREN RPAREN' 0969 self.functionObject ('operator ' + p [2], p[2]) 0970 self.arguments = [] 0971 0972 def p_cast_operator_name1 (self, p): 0973 'cast_operator_name : cast_operator_keyword type_specifier LPAREN RPAREN CVQUAL' 0974 fObj = self.functionObject ('operator ' + p [2], p[2]) 0975 fObj.addQualifier(p[5]) 0976 self.arguments = [] 0977 0978 def p_cast_operator_stmt (self, p): 0979 """cast_operator_stmt : cast_operator_name decl_end 0980 | virtual cast_operator_name decl_end""" 0981 self.currentFunction.setArguments(self.argumentList()) 0982 if len(p) == 4: 0983 self.currentFunction.addQualifier('virtual') 0984 0985 def p_operator_primary0 (self, p): 0986 """operator_primary : operator_name argument_list RPAREN 0987 | operator_name RPAREN""" 0988 if self.currentFunction is not None: 0989 self.currentFunction.setArguments(self.argumentList()) 0990 0991 def p_operator_primary1 (self, p): 0992 """operator_primary : virtual operator_name argument_list RPAREN 0993 | virtual operator_name RPAREN""" 0994 self.currentFunction.setArguments(self.argumentList()) 0995 self.currentFunction.addQualifier('virtual') 0996 0997 def p_operator_stmt0 (self, p): 0998 """operator_stmt : operator_primary decl_end 0999 | operator_primary pure_virtual_suffix decl_end""" 1000 pass 1001 1002 def p_operator_stmt1 (self, p): 1003 """operator_stmt : operator_primary CVQUAL decl_end 1004 | operator_primary CVQUAL pure_virtual_suffix""" 1005 if self.currentFunction is not None: 1006 self.currentFunction.addQualifier(p[2]) 1007 1008 def p_ctor_name0 (self, p): 1009 'ctor_name : qualified_id LPAREN' 1010 self.functionObject(p[1], 'ctor') 1011 self.arguments = [] 1012 1013 def p_ctor_name1 (self, p): 1014 'ctor_name : explicit qualified_id LPAREN' 1015 fo = self.functionObject(p[2], 'ctor') 1016 fo.addQualifier('explicit') 1017 self.arguments = [] 1018 1019 def p_dtor_name (self, p): 1020 'dtor_name : TILDE ID' 1021 self.functionObject(p[2], 'dtor') 1022 self.arguments = [] 1023 1024 def p_virtual_dtor_name (self, p): 1025 'virtual_dtor_name : virtual dtor_name' 1026 self.arguments = [] 1027 1028 def p_function_decl (self, p): 1029 """function_decl : ctor_stmt 1030 | dtor_stmt 1031 | function_stmt 1032 | operator_stmt 1033 | cast_operator_stmt 1034 | virtual_stmt 1035 | pure_virtual""" 1036 self.currentFunction = None 1037 1038 def p_function_primary (self, p): 1039 """function_primary : function_name RPAREN 1040 | function_name argument_list RPAREN""" 1041 self.currentFunction.setArguments(self.argumentList()) 1042 1043 def p_function_stmt0 (self, p): 1044 'function_stmt : function_primary decl_end' 1045 pass 1046 1047 def p_function_stmt1 (self, p): 1048 'function_stmt : function_primary CVQUAL decl_end' 1049 self.currentFunction.addQualifier(p[2]) 1050 1051 def p_ctor_primary (self, p): 1052 """ctor_primary : ctor_name RPAREN 1053 | ctor_name argument_list RPAREN""" 1054 self.currentFunction.setArguments(self.argumentList()) 1055 1056 def p_ctor_initializer (self, p): 1057 """ctor_initializer : qualified_id LPAREN expression_list RPAREN 1058 | qualified_id LPAREN RPAREN 1059 | template_type LPAREN expression_list RPAREN 1060 | template_type LPAREN RPAREN""" 1061 pass 1062 1063 def p_ctor_initializer_list (self, p): 1064 """ctor_initializer_list : ctor_initializer 1065 | ctor_initializer_list COMMA ctor_initializer""" 1066 1067 pass 1068 1069 def p_ctor_stmt (self, p): 1070 """ctor_stmt : ctor_primary decl_end 1071 | ctor_primary COLON ctor_initializer_list decl_end""" 1072 pass 1073 1074 def p_dtor_primary0 (self, p): 1075 'dtor_primary : dtor_name LPAREN RPAREN' 1076 pass 1077 1078 def p_dtor_primary1 (self, p): 1079 'dtor_primary_pure : dtor_name LPAREN RPAREN pure_virtual_suffix' 1080 self.currentFunction.addQualifier('pure') 1081 1082 1083 def p_dtor_primary2 (self, p): 1084 'dtor_primary : virtual_dtor_name LPAREN RPAREN' 1085 self.currentFunction.addQualifier('virtual') 1086 1087 def p_dtor_primary3 (self, p): 1088 'dtor_primary_pure_virtual : virtual_dtor_name LPAREN RPAREN pure_virtual_suffix' 1089 self.currentFunction.addQualifier('virtual') 1090 self.currentFunction.addQualifier('pure') 1091 1092 def p_dtor_stmt (self, p): 1093 """dtor_stmt : dtor_primary decl_end 1094 | dtor_primary_pure_virtual 1095 | dtor_primary_pure""" 1096 pass 1097 1098 def p_virtual_primary (self, p): 1099 """virtual_primary : virtual function_name RPAREN 1100 | virtual function_name argument_list RPAREN""" 1101 self.currentFunction.setArguments(self.argumentList()) 1102 self.currentFunction.addQualifier('virtual') 1103 1104 def p_virtual_stmt0 (self, p): 1105 'virtual_stmt : virtual_primary decl_end' 1106 pass 1107 1108 def p_virtual_stmt1 (self, p): 1109 'virtual_stmt : virtual_primary CVQUAL decl_end' 1110 self.currentFunction.addQualifier(p[2]) 1111 1112 def p_pure_virtual_suffix (self, p): 1113 'pure_virtual_suffix : EQUALS PURESFX' 1114 pass 1115 1116 def p_pure_virtual (self, p): 1117 """pure_virtual : virtual_primary pure_virtual_suffix 1118 | virtual_primary CVQUAL pure_virtual_suffix""" 1119 self.currentFunction.addQualifier('pure') 1120 if p[2] in ['const', 'volatile']: 1121 self.currentFunction.addQualifier(p[2]) 1122 1123 def p_template_param (self, p): 1124 """template_param : type_specifier 1125 | type_specifier ID""" 1126 p[0] = joinp(p, 1) 1127 1128 def p_template_param_list (self, p): 1129 """template_param_list : template_param""" 1130 p[0] = [p[1]] 1131 1132 def p_template_param_list2 (self, p): 1133 """template_param_list : template_param_list COMMA template_param""" 1134 p[1].append(p[3]) 1135 p[0] = p[1] 1136 1137 def p_template_decl (self, p): 1138 'template_decl : template LT template_param_list GT' 1139 p[0] = p[3] 1140 1141 def p_template_decl2 (self, p): 1142 'template_decl : template LT GT' 1143 p[0] = [] 1144 1145 # expression handling for argument default values - just parses and 1146 # then reassembles the default value expression (no evaluation) 1147 1148 def p_expression_list (self, p): 1149 """expression_list : expression 1150 | expression_list COMMA expression""" 1151 pass 1152 1153 def p_expression0 (self, p): 1154 """expression : add_expression 1155 | sub_expression 1156 | mult_expression 1157 | div_expression 1158 | mod_expression 1159 | unary_expression 1160 | or_expression 1161 | and_expression 1162 | xor_expression 1163 | bitor_expression 1164 | bitand_expression 1165 | lt_expression 1166 | le_expression 1167 | eq_expression 1168 | ge_expression 1169 | gt_expression 1170 | lshift_expression 1171 | rshift_expression 1172 | ptr_expression 1173 | dot_expression 1174 | new_expression 1175 | static_cast_expression 1176 | ICONST 1177 | FCONST 1178 | HEXCONST 1179 | CCONST 1180 | SCONST""" 1181 p [0] = p [1] 1182 1183 def p_expression1 (self, p): 1184 'expression : LPAREN expression RPAREN' 1185 p [0] = joinp(p, 1, "") 1186 1187 def p_expression2 (self, p): 1188 'expression : qualified_id' 1189 p [0] = p [1] 1190 self.exprElements.append (p [1]) 1191 1192 def p_expression3 (self, p): 1193 """expression : type_specifier LPAREN expression_list RPAREN 1194 | type_specifier LPAREN RPAREN""" 1195 p [0] = joinp(p, 1, "") 1196 self.exprElements.append ('%s()' % p [1]) 1197 1198 def p_expression4 (self, p): 1199 """expression : type_specifier PERIOD ID LPAREN expression_list RPAREN 1200 | type_specifier PERIOD ID LPAREN RPAREN""" 1201 p [0] = joinp(p, 1, "") 1202 self.exprElements.append ('%s.%s()' % (p [1], p [3])) 1203 1204 def p_expression5 (self, p): 1205 'expression : type_specifier PERIOD ID' 1206 p [0] = p [1] 1207 self.exprElements.append ('%s.%s' % (p [1], p [3])) 1208 1209 def p_expression_list (self, p): 1210 """expression_list : expression 1211 | expression_list COMMA expression""" 1212 p [0] = joinp(p, 1, "") 1213 1214 def p_unary_expression (self, p): 1215 """unary_expression : sign_expression 1216 | not_expression 1217 | bitnot_expression 1218 | new_expression""" 1219 p [0] = p [1] 1220 1221 def p_add_expression (self, p): 1222 'add_expression : expression PLUS expression' 1223 p [0] = joinp(p, 1, "") 1224 1225 def p_sub_expression (self, p): 1226 'sub_expression : expression MINUS expression' 1227 p [0] = joinp(p, 1, "") 1228 1229 def p_mult_expression (self, p): 1230 'mult_expression : expression ASTERISK expression' 1231 p [0] = joinp(p, 1, "") 1232 1233 def p_div_expression (self, p): 1234 'div_expression : expression SLASH expression' 1235 p [0] = joinp(p, 1, "") 1236 1237 def p_mod_expression (self, p): 1238 'mod_expression : expression PERCENT expression' 1239 p [0] = joinp(p, 1, "") 1240 1241 def p_sign_expression (self, p): 1242 'sign_expression : MINUS expression %prec UMINUS' 1243 p [0] = joinp(p, 1, "") 1244 1245 def p_or_expression (self, p): 1246 'or_expression : expression LOR expression' 1247 p [0] = joinp(p, 1, "") 1248 1249 def p_and_expression (self, p): 1250 'and_expression : expression LAND expression' 1251 p [0] = joinp(p, 1, "") 1252 1253 def p_xor_expression (self, p): 1254 'xor_expression : expression CARET expression' 1255 p [0] = joinp(p, 1, "") 1256 1257 def p_bitor_expression (self, p): 1258 'bitor_expression : expression VBAR expression' 1259 p [0] = joinp(p, 1, "") 1260 1261 def p_bitand_expression (self, p): 1262 'bitand_expression : expression AMPERSAND expression' 1263 p [0] = joinp(p, 1, "") 1264 1265 def p_lt_expression (self, p): 1266 'lt_expression : expression LT expression' 1267 p [0] = joinp(p, 1, "") 1268 1269 def p_le_expression (self, p): 1270 'le_expression : expression LE expression' 1271 p [0] = joinp(p, 1, "") 1272 1273 def p_eq_expression (self, p): 1274 'eq_expression : expression EQ expression' 1275 p [0] = joinp(p, 1, "") 1276 1277 def p_ge_expression (self, p): 1278 'ge_expression : expression GE expression' 1279 p [0] = joinp(p, 1, "") 1280 1281 def p_gt_expression (self, p): 1282 'gt_expression : expression GT expression' 1283 p [0] = joinp(p, 1, "") 1284 1285 def p_lshift_expression (self, p): 1286 'lshift_expression : expression GT GT expression' 1287 p [0] = joinp(p, 1, "") 1288 1289 def p_rshift_expression (self, p): 1290 'rshift_expression : expression LT LT expression' 1291 p [0] = joinp(p, 1, "") 1292 1293 def p_not_expression (self, p): 1294 'not_expression : BANG expression' 1295 p [0] = joinp(p, 1, "") 1296 1297 def p_bitnot_expression (self, p): 1298 'bitnot_expression : TILDE expression' 1299 p [0] = joinp(p, 1, "") 1300 1301 def p_new_expression (self, p): 1302 'new_expression : new expression' 1303 p [0] = joinp(p, 1, "") 1304 1305 def p_static_cast_expression (self, p): 1306 'static_cast_expression : static_cast LT type_specifier GT LPAREN expression RPAREN' 1307 p [0] = joinp(p, 1) 1308 self.exprElements.append (p [3]) 1309 1310 def p_ptr_expression (self, p): 1311 'ptr_expression : expression ARROW expression' 1312 p [0] = joinp(p, 1, "") 1313 1314 def p_dot_expression (self, p): 1315 'dot_expression : expression PERIOD expression' 1316 p [0] = joinp(p, 1, "") 1317 1318 # inline code/statements 1319 # the second and last cases are incorrect syntax, but show up in KDE 1320 def p_inline_code (self, p): 1321 """inline_code : STMT_BEGIN code_list STMT_END 1322 | STMT_BEGIN code_list STMT_END SEMI 1323 | STMT_BEGIN STMT_END 1324 | STMT_BEGIN STMT_END SEMI""" 1325 pass 1326 1327 def p_code_list_block (self, p): 1328 """code_list_block : CODE_STMT_BEGIN code_list STMT_END 1329 | CODE_STMT_BEGIN STMT_END""" 1330 pass 1331 1332 def p_code_list (self, p): 1333 """code_list : CODE_TOKEN 1334 | code_list_block 1335 | code_list code_list_block 1336 | code_list CODE_TOKEN""" 1337 1338 # calls to mostly ignored macros 1339 def p_skip_macro (self, p): 1340 'skip_macro : MACROCALL MACRO_CALL_BEGIN macro_call_element_list MACRO_CALL_END' 1341 #if p [1] == 'Q_DISABLE_COPY': 1342 # fcn = self.functionObject (p [3], 'ctor') 1343 # fcn.setArguments (self.argument ('const %s&' % p[3])) 1344 # self.stateInfo.popObject () 1345 #else: 1346 # pass 1347 macro = self.bareMacro(p[1]) 1348 macro.setArgument(p[3]) 1349 macro.setAccess(self.access) 1350 1351 def p_bare_macro(self,p): 1352 'bare_macro : BAREMACRO' 1353 macro = self.bareMacro(p[1]) 1354 macro.setAccess(self.access) 1355 1356 def p_macro_call_parens (self, p): 1357 """macro_call_parens : LPAREN RPAREN 1358 | LPAREN macro_call_element_list RPAREN""" 1359 pass 1360 1361 def p_macro_call_element_list0 (self, p): 1362 'macro_call_element_list : MACRO_ELEMENT' 1363 p [0] = p[1] 1364 1365 def p_macro_call_element_list1 (self, p): 1366 'macro_call_element_list : macro_call_element_list MACRO_ELEMENT' 1367 p [0] = joinp(p, 1) 1368 1369 def p_macro_call_element_list2 (self, p): 1370 'macro_call_element_list : macro_call_element_list macro_call_parens' 1371 p [0] = p [1] 1372 1373 def p_macro_call_element_list3 (self, p): 1374 'macro_call_element_list : macro_call_parens' 1375 p [0] = '' 1376 1377 def p_doccomment(self, p): 1378 'doccomment : DOC' 1379 self.commentObject(p[1]) 1380 1381 def p_error(self, p): 1382 if p is not None: 1383 print("File: " + repr(self.filename) + " Line: " + str(self.lexer.lineno) + " Syntax error in input. Token type: %s, token value: %s, lex state: %s" % (p.type, p.value, self.lexer.lexstate)) 1384 else: 1385 print("File: " + repr(self.filename) + " Line: " + str(self.lexer.lineno) + " Syntax error in input. Lex state: %s" % (self.lexer.lexstate,) ) 1386 sys.exit (-1) 1387 1388 if __name__ == '__main__': 1389 1390 text = """ 1391 enum global {earth, orb, globe}; 1392 friend class whatever; 1393 friend int max (int a, int b); 1394 1395 namespace foo 1396 { 1397 enum fooEnum {apples, peaches, pumpkin_pie}; 1398 class bar 1399 { 1400 public: 1401 bar (); 1402 int baz (); 1403 int baz (double, long); 1404 QString method (int foo = 0); 1405 bar (int); 1406 bar (int, QList<QString>); 1407 using dont care what; 1408 enum barEnum { 1409 peas, 1410 carrots, 1411 beans 1412 } veggies; 1413 typedef global::qint inttype; 1414 }; 1415 typedef enum elaborated something; 1416 typedef enum simple {easy, bobsyouruncle, noproblem}; 1417 typedef QList<QPair<QString,QString>> stringpairlist; 1418 typedef QString& stringref; 1419 typedef QObject* objPtr; 1420 typedef QObject** objPtrPtr; 1421 typedef QString*& reftoStringPtr; 1422 enum tail {end, posterior, ass}; 1423 } 1424 int baz (); 1425 virtual int baz (double); 1426 int baz (double, long long); 1427 int baz (double, long, unsigned long = ulong); 1428 virtual const QString& method (int foo = 0) = 0; 1429 QString method (int foo = 0, long fool = 20); 1430 bar (int a[40]); 1431 bar (int, QList<QString>); 1432 char* tmpl (QPair<QString, QString*> pair, const int foo); 1433 const char* string (QObject* object = QObject::type ()); 1434 int varInt; 1435 double varDbl1, varDb12; 1436 QString s = 25; 1437 bar (int); 1438 bar (int a[40]); 1439 char *c[10]; 1440 typedef void (* fptr)(int, double*); 1441 typedef int (* otherptr)(); 1442 Q_OBJECT 1443 Q_SETS (who cares) 1444 double (*doublePtr)(float, QString*); 1445 bool test (int, int); 1446 bool operator == (int); 1447 int operator + (double); 1448 int operator >> (int); 1449 bool operator <<= (int a, int b); 1450 double (*doublePtr)(); 1451 void* foo (int, double (*doublePtr)(float, QString*)); 1452 void* foo (int, double (*doublePtr)()); 1453 Q_DECLARE_FLAGS (Conditions, Condition) 1454 void plug () { 1455 x = 1; 1456 y = 2; 1457 } 1458 class kdecore::KAccel raise (class QWidget elab) { 1459 xyzabc = 1; 1460 y = 2; 1461 { 1462 if (x) 1463 { 1464 abc = 12; 1465 } 1466 } 1467 { 1468 while 1: 1469 x = 0; 1470 } 1471 1472 } 1473 """ 1474 text = """ 1475 1476 namespace Soprano { 1477 1478 class Model; 1479 1480 namespace Client { 1481 1482 class DBusModel; 1483 1484 /** 1485 * \class DBusClient dbusclient.h Soprano/Client/DBusClient 1486 * 1487 * \brief Core class to handle a connection to a Soprano server through the 1488 * DBus interface. 1489 * 1490 * DBusClient creates a connection to a running Soprano Server via its DBus 1491 * interface. All DBus communication is handled internally. 1492 * 1493 * See DBusModel for details about thread-safety. 1494 * 1495 * \author Sebastian Trueg <trueg@kde.org> 1496 * 1497 * \sa \ref soprano_server_dbus 1498 */ 1499 class DBusClient : public QObject, public Error::ErrorCache 1500 { 1501 1502 }; 1503 } 1504 } 1505 1506 """ 1507 text = """ 1508 class Foo { 1509 public: 1510 const KTimeZone::Transition *transition(const QDateTime &dt, const Transition **secondTransition = 0, bool *validTime = 0) const; 1511 }; 1512 """ 1513 1514 from symboldata import Data 1515 from stateInfo import StateInfo 1516 1517 symbolData = Data () 1518 stateInfo = StateInfo () 1519 parser = CppParser () 1520 # print "\n".join (parser.parse (symbolData, stateInfo, text, 2) [1]) 1521 parser.parse (symbolData, stateInfo, text, 2)