def GenerateTags(buff): """Create a DocStruct object that represents an Inno Setup Script @param buff: a file like buffer object (StringIO) @todo: perhaps group functions, procedures within the Scope of a Section object. """ rtags = taglib.DocStruct() rtags.SetElementDescription('section', "Sections") rtags.SetElementDescription('variable', "Defines") rtags.SetElementDescription('function', "Function Definitions") rtags.SetElementDescription('procedure', "Procedure Definitions") rtags.SetElementPriority('section', 3) rtags.SetElementPriority('function', 2) rtags.SetElementPriority('procedure', 1) for lnum, line in enumerate(buff): line = line.strip() # Skip comment and empty lines if line.startswith(u";") or not line: continue # Check for a section if line.startswith(u"["): secend = line.find(u"]") if secend != -1: section = taglib.Section(line[1:secend], lnum) rtags.AddElement('section', section) elif parselib.IsToken(line, 0, u'function'): name = parselib.GetFirstIdentifier(line[8:].strip()) if name is not None: rtags.AddFunction(taglib.Function(name, lnum)) elif parselib.IsToken(line, 0, u'procedure'): name = parselib.GetFirstIdentifier(line[9:].strip()) if name is not None: rtags.AddElement('procedure', taglib.Function(name, lnum, 'procedure')) elif parselib.IsToken(line, 0, u'#define'): name = parselib.GetFirstIdentifier(line[7:].strip()) if name is not None: rtags.AddVariable(taglib.Variable(name, lnum)) else: pass return rtags
def GenerateTags(buff): """Create a DocStruct object that represents a Tcl Script @param buff: a file like buffer object (StringIO) """ rtags = taglib.DocStruct() rtags.SetElementDescription('procedure', "Procedure Definitions") for lnum, line in enumerate(buff): line = line.strip() # Skip comment and empty lines if line.startswith(u"#") or not line: continue # Check for Procedure defs if parselib.IsToken(line, 0, u'proc'): parts = line.split() if len(parts) > 1 and parts[1].isalnum(): rtags.AddElement('procedure', taglib.Procedure(parts[1], lnum)) return rtags
def GenerateTags(buff): """Create a DocStruct object that represents Ada source code @param buff: a file like buffer object (StringIO) """ rtags = taglib.DocStruct() rtags.SetElementDescription('procedure', "Procedure Definitions") for lnum, line in enumerate(buff): line = line.strip() # Skip comment and empty lines if line.startswith(u"--") or not line: continue # Check Regular Function Defs if parselib.IsToken(line, 0, u'procedure'): name = parselib.GetFirstIdentifier(line[9:].strip()) if name is not None: rtags.AddElement('procedure', taglib.Function(name, lnum, 'procedure')) return rtags
def GenerateTags(buff): """Create a DocStruct object that represents a MatLab/Octave document @param buff: a file like buffer object (StringIO) """ rtags = taglib.DocStruct() rtags.SetElementDescription('function', "Function Definitions") # Do the parse for lnum, line in enumerate(buff): line = line.strip() # Skip comment and empty lines if line.startswith(u"%") or line.startswith(u"#") or not line: continue # Check Regular Function Defs if parselib.IsToken(line, 0, u'function'): name = parselib.GetFirstIdentifier(line[8:]) if name is not None and len(name): rtags.AddFunction(taglib.Function(name, lnum)) continue return rtags
def GenerateTags(buff): """Create a DocStruct object that represents a vala dacument @param buff: a file like buffer object (StringIO) """ rtags = taglib.DocStruct() # Setup document structure rtags.SetElementDescription('function', "Function Definitions") inclass = False # Inside a class defintion incomment = False # Inside a comment infundef = False # Inside a function definition lastclass = None lastfun = None openb = 0 # Keep track of open brackets for lnum, line in enumerate(buff): line = line.strip() llen = len(line) idx = 0 while idx < len(line): # Skip Whitespace idx = parselib.SkipWhitespace(line, idx) # Check for coments if line[idx:].startswith(u'/*'): idx += 2 incomment = True elif line[idx:].startswith(u'//') or line[idx:].startswith(u'#'): break # go to next line elif line[idx:].startswith(u'*/'): idx += 2 incomment = False # At end of line if idx >= llen: break # Look for tags if incomment: idx += 1 continue elif line[idx] == u'{': idx += 1 openb += 1 # Class name must be followed by a { if not inclass and lastclass is not None: inclass = True rtags.AddClass(lastclass) elif lastfun is not None: infundef = True lastfun = None else: pass continue elif line[idx] == u'}': idx += 1 openb -= 1 if inclass and openb == 0: inclass = False lastclass = None elif infundef and inclass and openb == 1: infundef = False elif infundef and openb == 0: infundef = False lastfun = None else: pass continue elif not infundef and parselib.IsToken(line, idx, u'class'): # Skip whitespace idx = parselib.SkipWhitespace(line, idx + 5) name = parselib.GetFirstIdentifier(line[idx:]) if name is not None: idx += len(name) # Move past the class name lastclass = taglib.Class(name, lnum) continue match = RE_METH.match(line[idx:]) if match is not None: # Check that not a method call sline = line.strip() if sline.endswith(u';'): idx += match.end(2) continue # Most likely a definition so store it in the DocStruct name = match.group(2) # Secondary check for other end cases regex will find if name in KEYWORDS: idx += match.end(2) continue lastfun = name if inclass and lastclass is not None: lastclass.AddMethod( taglib.Method(name, lnum, lastclass.GetName())) else: rtags.AddFunction(taglib.Function(name, lnum)) idx += match.end(2) else: idx += 1 return rtags
def GenerateTags(buff): """Create a DocStruct object that represents a Php Script @param buff: a file like buffer object (StringIO) """ rtags = taglib.DocStruct() # Setup document structure rtags.SetElementDescription('function', "Function Definitions") inphp = False # Are we in a php section or not inclass = False # Inside a class defintion incomment = False # Inside a comment infundef = False # Inside a function definition lastclass = None lastfun = None instring = False openb = 0 # Keep track of open brackets for lnum, line in enumerate(buff): line = line.strip() llen = len(line) idx = 0 while idx < len(line): # Skip Whitespace idx = parselib.SkipWhitespace(line, idx) # Walk through strings ignoring contents if instring or line[idx] in (u"'", u'"'): idx, instring = parselib.FindStringEnd(line[idx:], idx) # For multiline strings if instring: continue # Check if in a <?php ?> block or not if line[idx:].startswith(u'<?'): idx += 2 if line[idx:].startswith(u'php'): idx += 5 inphp = True elif line[idx:].startswith(u'?>'): idx += 2 inphp = False # Skip anything not in side of a php section if not inphp: idx += 1 continue # Check for coments if line[idx:].startswith(u'/*'): idx += 2 incomment = True elif line[idx:].startswith(u'//') or line[idx:].startswith(u'#'): break # go to next line elif line[idx:].startswith(u'*/'): idx += 2 incomment = False # At end of line if idx >= llen: break # Look for tags if incomment: idx += 1 elif line[idx] == u'{': idx += 1 openb += 1 # Class name must be followed by a { if not inclass and lastclass is not None: inclass = True rtags.AddClass(lastclass) elif lastfun is not None: infundef = True lastfun = None else: pass elif line[idx] == u'}': idx += 1 openb -= 1 if inclass and openb == 0: inclass = False lastclass = None elif infundef and inclass and openb == 1: infundef = False elif infundef and openb == 0: infundef = False lastfun = None else: pass elif not infundef and parselib.IsToken(line, idx, u'class'): # Skip whitespace idx = parselib.SkipWhitespace(line, idx + 5) name = parselib.GetFirstIdentifier(line[idx:]) if name is not None: idx += len(name) # Move past the class name lastclass = taglib.Class(name, lnum) elif parselib.IsToken(line, idx, u'function'): # Skip whitespace idx = parselib.SkipWhitespace(line, idx + 8) name = parselib.GetFirstIdentifier(line[idx:]) if name is not None: lastfun = name # Skip whitespace idx = parselib.SkipWhitespace(line, idx + len(name)) if line[idx] != u'(': continue if inclass and lastclass is not None: lastclass.AddMethod(taglib.Method(name, lnum, lastclass.GetName())) else: rtags.AddFunction(taglib.Function(name, lnum)) elif inclass and parselib.IsToken(line, idx, u'var'): # Look for class variables idx += 3 parts = line[idx:].split() if len(parts) and parts[0].startswith(u'$'): name = parselib.GetFirstIdentifier(parts[0][1:]) if name is not None and lastclass is not None: name = u'$' + name lastclass.AddVariable(taglib.Variable(name, lnum, lastclass.GetName())) idx += len(name) else: idx += 1 return rtags
def GenerateTags(buff): """Create a DocStruct object that represents a Tcl Script @param buff: a file like buffer object (StringIO) """ rtags = taglib.DocStruct() rtags.SetElementDescription('procedure', "Procedure Definitions") rtags.SetElementDescription('class', "SNIT") # Scope tracking for SNIT blocks insnit = False cursnit = None openparens = 0 for lnum, line in enumerate(buff): line = line.strip() # Skip comment and empty lines if line.startswith(u"#") or not line: continue if insnit and cursnit is not None: if parselib.IsToken(line, 0, u'method') or \ parselib.IsToken(line, 0, u'typemethod'): parts = line.split() if len(parts) > 1: name = parts[1] cursnit.AddMethod(taglib.Method(name, lnum)) elif parselib.IsToken(line, 0, u'typevariable') or \ parselib.IsToken(line, 0, u'variable'): parts = line.split() if len(parts) > 1: name = parts[1] cursnit.AddVariable(taglib.Variable(name, lnum)) elif parselib.IsToken(u'constructor', 0, line) or \ parselib.IsToken(u'destructor', 0, line): name = parselib.GetFirstIdentifier(line) cursnit.AddMethod(taglib.Method(name, lnum)) elif parselib.IsToken(line, 0, u"package"): pkg = GetPackage(line, lnum) if pkg: cursnit.AddElement('package', pkg) # Update Scope openparens += GetParenCount(line) if openparens == 0: insnit = False cursnit = None continue # Check for Procedure defs if parselib.IsToken(line, 0, u'proc'): parts = line.split() if len(parts) > 1: name = parts[1] if u"::" in name: spaces = name.split("::") space_l = rtags.GetElement('namespace', spaces[0]) if space_l == None: space_l = taglib.Namespace(spaces[0], lnum) rtags.AddElement('namespace', space_l) space_l.AddElement('procedure', taglib.Procedure(spaces[-1], lnum)) else: rtags.AddElement('procedure', taglib.Procedure(parts[1], lnum)) elif line.startswith(u'snit::'): parts = line.split() if len(parts) > 1: insnit = True openparens = GetParenCount(line) name = parts[1] cursnit = taglib.Class(name, lnum) rtags.AddClass(cursnit) elif parselib.IsToken(line, 0, u"package"): pkg = GetPackage(line, lnum) if pkg: rtags.AddElement('package', pkg) return rtags
def GenerateTags(buff): """Create a DocStruct object that represents a SQL document @param buff: a file like buffer object (StringIO) """ rtags = taglib.DocStruct() # Setup document structure rtags.SetElementDescription('function', "Function Definitions") rtags.SetElementDescription('procedure', "Procedure Definitions") rtags.SetElementDescription('package', "Packages") rtags.SetElementPriority('package', 3) rtags.SetElementPriority('function', 2) rtags.SetElementPriority('procedure', 1) # State Variables inpackage = False # Inside a package incomment = False # Inside a comment infunpro = False # Inside a function or proceedure definition lastname = None # Name of last found element lastpkg = None # Last found package object lastpkgname = None # Name of last package for lnum, line in enumerate(buff): line = line.strip() llen = len(line) idx = 0 while idx < len(line): # Skip Whitespace idx = parselib.SkipWhitespace(line, idx) # Check for coments if line[idx:].startswith(u'/*'): idx += 2 incomment = True elif line[idx:].startswith(u'--') or line[idx:].startswith(u'#'): break # go to next line elif line[idx:].startswith(u'*/'): idx += 2 incomment = False # At end of line if idx >= llen: break # Look for tags if incomment: idx += 1 elif (inpackage or infunpro) and \ parselib.IsToken(line, idx, u'end', True): idx = parselib.SkipWhitespace(line, idx + 3) name = parselib.GetFirstIdentifier(line[idx:]) if inpackage and name == lastpkgname: inpackage = False lastpkgname = None elif infunpro and name == lastname: infunpro = False lastname = None elif not infunpro and parselib.IsToken(line, idx, u'package', True): # Skip whitespace idx = parselib.SkipWhitespace(line, idx + 7) name = parselib.GetFirstIdentifier(line[idx:]) if name is not None and name.lower() == u'body': idx = parselib.SkipWhitespace(line, idx + 3) name = parselib.GetFirstIdentifier(line[idx:]) if name is not None: inpackage = True lastpkgname = name lastpkg = taglib.Package(name, lnum) rtags.AddElement('package', lastpkg) elif parselib.IsToken(line, idx, u'function', True): # Skip whitespace idx = parselib.SkipWhitespace(line, idx + 8) name = parselib.GetFirstIdentifier(line[idx:]) if name is not None: infunpro = True lastname = name if lastpkg is not None: lastpkg.AddElement('function', taglib.Function(name, lnum)) else: rtags.AddFunction(taglib.Function(name, lnum)) elif parselib.IsToken(line, idx, u'procedure', True): # Skip whitespace idx = parselib.SkipWhitespace(line, idx + 9) name = parselib.GetFirstIdentifier(line[idx:]) if name is not None: infunpro = True lastname = name if lastpkg is not None: lastpkg.AddElement('procedure', taglib.Procedure(name, lnum)) else: rtags.AddElement('procedure', taglib.Procedure(name, lnum)) else: idx += 1 return rtags
def GenerateTags(buff): """Create a DocStruct object that represents a haXe Script @param buff: a file like buffer object (StringIO) """ rtags = taglib.DocStruct() # Setup document structure rtags.SetElementDescription('class', "Class Definitions") rtags.SetElementDescription('function', "Function Definitions") inclass = False # Inside a class defintion incomment = False # Inside a comment infundef = False # Inside a function definition lastclass = None lastfun = None openb = 0 # Keep track of open brackets for lnum, line in enumerate(buff): line = line.strip() llen = len(line) idx = 0 while idx < len(line): # Skip Whitespace idx = parselib.SkipWhitespace(line, idx) # Check for coments if line[idx:].startswith(u'/*'): idx += 2 incomment = True elif line[idx:].startswith(u'//'): break # go to next line elif line[idx:].startswith(u'*/'): idx += 2 incomment = False # At end of line if idx >= llen: break # Look for tags if incomment: idx += 1 elif line[idx] == u'{': idx += 1 openb += 1 # Class name must be followed by a { if not inclass and lastclass is not None: inclass = True rtags.AddClass(lastclass) elif lastfun is not None: infundef = True lastfun = None else: pass elif line[idx] == u'}': idx += 1 openb -= 1 if inclass and openb == 0: inclass = False lastclass = None elif infundef and inclass and openb == 1: infundef = False elif infundef and openb == 0: infundef = False lastfun = None else: pass elif not infundef and parselib.IsToken(line, idx, u'class'): # Skip whitespace idx = parselib.SkipWhitespace(line, idx + 5) name = parselib.GetFirstIdentifier(line[idx:]) if name is not None: idx += len(name) # Move past the class name lastclass = taglib.Class(name, lnum) elif parselib.IsToken(line, idx, u'function'): # Skip whitespace idx = parselib.SkipWhitespace(line, idx + 8) name = parselib.GetFirstIdentifier(line[idx:]) if name is not None: lastfun = name # Skip whitespace idx = parselib.SkipWhitespace(line, idx + len(name)) if line[idx] != u'(': continue if inclass and lastclass is not None: lastclass.AddMethod( taglib.Method(name, lnum, lastclass.GetName())) else: rtags.AddFunction(taglib.Function(name, lnum)) elif inclass and not infundef and parselib.IsToken( line, idx, u'var'): # Look for class variables idx = parselib.SkipWhitespace(line, idx + 3) name = parselib.GetFirstIdentifier(line[idx:]) if name is not None and lastclass is not None: lastclass.AddVariable( taglib.Variable(name, lnum, lastclass.GetName())) idx += len(name) else: idx += 1 return rtags
def GenerateTags(buff): """Create a DocStruct object that represents a Python file @param buff: a file like buffer object (StringIO) """ rtags = taglib.DocStruct() rtags.SetElementDescription('function', "Function Definitions") rtags.SetElementDescription('class', "Class Definitions") # Variables for managing the state of the parse parents = list() indent = 0 fn_indent = 0 parens = 0 # Paren nesting count indocstring = False ind_string = False # Double quote string ins_string = False # Single quote string infunction = False lastclass = None def NotInString(): """Return whether the current state of the parse is in a string or not. """ return not indocstring and not ind_string and not ins_string # Do the parse of the text for lnum, line in enumerate(buff): indent = 0 idx = 0 llen = len(line) while idx < llen: # Check for docstrings if not (ind_string or ins_string) and llen >= idx + 3 and line[idx:idx + 3] in [ '"""', "'''" ]: indocstring = not indocstring idx += 3 continue # If end of line or start of comment start next line if idx == llen or (line[idx] == u"#" and NotInString()): break # Check indent sensitive tokens if not indocstring and not line[idx].isspace(): if infunction and indent < fn_indent: infunction = False if lastclass is not None: if indent <= lastclass.get('indent', 0): parents = PopScopes(parents, indent) if len(parents): lastclass = parents[-1] else: lastclass = None # Check for if in a string or not if line[idx] == u"'" and not ind_string and \ idx > 0 and line[idx-1] != "\\": # Single string ins_string = not ins_string idx += 1 elif line[idx] == u'"' and not ins_string and \ idx > 0 and line[idx-1] != "\\": # Double String ind_string = not ind_string idx += 1 else: pass # Parse and look for elements to add to the DocStruct if not NotInString(): # Token is in a string so ignore and move on idx = idx + 1 elif line[idx].isspace(): # Get indent width for current scope if idx == 0: indent = (len(line) - len(line.lstrip())) idx += indent else: # Non indent space idx += 1 elif parselib.IsToken(line, idx, u'class'): idx += 5 cname = parselib.GetFirstIdentifier(line[idx:]) if cname is not None: if lastclass is None: rtags.AddClass(taglib.Class(cname, lnum)) # TODO: check for classes defined within classes lastclass = dict(name=cname, indent=indent) parents.append(dict(lastclass)) break # Go to next line elif parselib.IsToken(line, idx, u'def'): # Function/Method Definition idx += 3 fname = parselib.GetFirstIdentifier(line[idx:]) if line[idx].isspace() and fname is not None: infunction = True fn_indent = indent + 1 if not line[0].isspace() or lastclass is None or \ not len(lastclass.get("name", "")): rtags.AddFunction(taglib.Function(fname, lnum)) else: lclass = rtags.GetLastClass() if lclass is not None: lclass.AddMethod( taglib.Method(fname, lnum, lclass.GetName())) else: # Something must have failed with the parse so # ignore this element. pass break elif not infunction and line[idx] in u"()": # Track paren nesting to help with variable parsing if line[idx] == u"(": parens += 1 else: parens -= 1 idx += 1 elif not infunction and line[idx] == u"=" and not parens: # Check for Global and Class variables idx += 1 if line[idx] != u"=": # ignore == statements var = line[:idx - 1].strip().split() if len(var) == 1 and parselib.IsGoodName(var[0]): lclass = rtags.GetLastClass() # Check if we are still inside a class def or not if lastclass is not None and lclass is not None: vobj = taglib.Variable(var[0], lnum, lclass.GetName()) lclass.AddVariable(vobj) else: # Global Scope variable rtags.AddVariable(taglib.Variable(var[0], lnum)) else: # Nothing so skip ahead idx += 1 # Return the document structure object return rtags
def GenerateTags(buff): """Create a DocStruct object that represents a Verilog document @param buff: a file like buffer object (StringIO) @todo: add support for parsing module definitions / class variables """ rtags = taglib.DocStruct() rtags.SetElementDescription('class', "Class Definitions") rtags.SetElementDescription('task', "Task Definitions") rtags.SetElementDescription('function', "Function Definitions") rtags.SetElementPriority('class', 3) rtags.SetElementPriority('task', 2) rtags.SetElementPriority('function', 1) # Variables to track parse state inclass = False # Inside a class defintion incomment = False # Inside a comment intask = False # Inside a task definition infunction = False # Inside a function definition # Parse the text for lnum, line in enumerate(buff): line = line.strip() llen = len(line) idx = 0 while idx < len(line): # Skip any leading Whitespace idx = parselib.SkipWhitespace(line, idx) # Check for coments if line[idx:].startswith(u'/*'): idx += 2 incomment = True elif line[idx:].startswith(u'//'): break # go to next line elif line[idx:].startswith(u'*/'): idx += 2 incomment = False # At end of line if idx >= llen: break # Look for tags if incomment: idx += 1 elif parselib.IsToken(line, idx, u'class'): idx = parselib.SkipWhitespace(line, idx + 5) cname = parselib.GetFirstIdentifier(line[idx:]) if cname is not None: inclass = True rtags.AddClass(taglib.Class(cname, lnum)) break # go to next line elif inclass and parselib.IsToken(line, idx, u'endclass'): inclass = False break # go to next line elif parselib.IsToken(line, idx, u'task'): idx += 4 tname = parselib.GetTokenParenLeft(line[idx:]) if tname is not None: intask = True if inclass: lclass = rtags.GetLastClass() task = taglib.Function(tname, lnum, 'task', lclass.GetName()) lclass.AddElement('task', task) else: task = taglib.Function(tname, lnum, 'task') rtags.AddElement('task', task) break # goto next line elif parselib.IsToken(line, idx, u'function'): idx += 8 fname = parselib.GetTokenParenLeft(line[idx:]) if fname is not None: infunction = True if inclass: lclass = rtags.GetLastClass() lclass.AddMethod(taglib.Method(fname, lnum)) else: rtags.AddFunction(taglib.Function(fname, lnum)) break elif intask and parselib.IsToken(line, idx, u'endtask'): intask = False break # go to next line elif infunction and parselib.IsToken(line, idx, 'endfunction'): infunction = False break else: idx += 1 return rtags
def GenerateTags(buff): """Create a DocStruct object that represents a Ferite document @param buff: a file like buffer object (StringIO) """ rtags = taglib.DocStruct() # Setup document structure rtags.SetElementDescription('namespace', "Namespaces") rtags.SetElementDescription('class', "Class Definitions") rtags.SetElementDescription('protocol', "Protocols") rtags.SetElementDescription('function', "Function Definitions") rtags.SetElementPriority('namespace', 4) rtags.SetElementPriority('class', 3) rtags.SetElementPriority('protocol', 2) rtags.SetElementPriority('function', 1) # Variables for tracking parse state incomment = False # Inside a comment innamespace = False # Inside a namespace inclass = False # Inside a class defintion inprotocol = False # Inside a protocol infundef = False # Inside a function definition lastnspace = None # Last Namespace lastclass = None # Last Class lastprotocol = None # Last Protocol lastfun = None # last Function openb = 0 # Keep track of open brackets for scope resolution def InSubScope(): return innamespace or inclass or inprotocol or infundef # Parse the contents of the buffer for lnum, line in enumerate(buff): line = line.strip() llen = len(line) idx = 0 while idx < len(line): # Skip Whitespace idx = parselib.SkipWhitespace(line, idx) # Check for comments if line[idx:].startswith(u'/*'): idx += 2 incomment = True elif line[idx:].startswith(u'//'): break # go to next line elif line[idx:].startswith(u'*/'): idx += 2 incomment = False # At end of line if idx >= llen: break # Look for tags if incomment: idx += 1 elif line[idx] == u'{': idx += 1 openb += 1 # Namespace/Class/Protocol names must be followed by a { if not InSubScope() and lastnspace is not None: innamespace = True rtags.AddElement('namespace', lastnspace) elif not inclass and lastclass is not None: inclass = True if lastnspace is not None: # Class is in a namespace lastnspace.AddElement('class', lastclass) else: # Class is at the global scope rtags.AddClass(lastclass) elif not InSubScope() and lastprotocol is not None: inprotocol = True rtags.AddElement('protocol', lastprotocol) elif lastfun is not None: infundef = True lastfun = None else: pass elif line[idx] == u'}': idx += 1 openb -= 1 # Check if the scope needs to change if innamespace and openb == 0: innamespace = False lastnspace = None elif innamespace and inclass and openb == 1: inclass = False lastclass = None elif (innamespace and inclass and infundef and openb == 2) or \ (innamespace and infundef and openb == 1): infundef = False lastfun = None elif inclass and openb == 0: inclass = False lastclass = None elif inclass and infundef and openb == 1: infundef = False lastfun = None elif inprotocol and openb == 0: inprotocol = False lastprotocol = None elif inprotocol and infundef and openb == 1: infundef = False lastfun = None elif infundef and openb == 0: infundef = False lastfun = None else: pass elif not infundef and parselib.IsToken(line, idx, u'class'): # Skip whitespace idx = parselib.SkipWhitespace(line, idx + 5) name = parselib.GetFirstIdentifier(line[idx:]) if name is not None: idx += len(name) # Move past the class name lastclass = taglib.Class(name, lnum) elif not infundef and not inclass and \ parselib.IsToken(line, idx, 'namespace'): idx = parselib.SkipWhitespace(line, idx + 9) name = GetElementName(line[idx:]) if name is not None: idx += len(name) lastnspace = taglib.Namespace(name, lnum) elif parselib.IsToken(line, idx, u'protocol'): idx = parselib.SkipWhitespace(line, idx + 8) name = parselib.GetFirstIdentifier(line[idx:]) if name is not None: idx += len(name) lastprotocol = Protocol(name, lnum) elif parselib.IsToken(line, idx, u'function'): # Skip whitespace idx = parselib.SkipWhitespace(line, idx + 8) name = parselib.GetFirstIdentifier(line[idx:]) if name is not None: lastfun = name # Skip whitespace idx = parselib.SkipWhitespace(line, idx + len(name)) if line[idx] != u'(': continue tfun = taglib.Function(name, lnum) if innamespace and not inclass and lastnspace: lastnspace.AddElement('function', tfun) elif inclass and lastclass is not None: lastclass.AddMethod( taglib.Method(name, lnum, lastclass.GetName())) elif inprotocol and lastprotocol is not None: lastprotocol.AddElement('function', tfun) else: rtags.AddFunction(tfun) else: idx += 1 return rtags