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 line.startswith(u"function") and \ len(line) > 8 and line[8].isspace(): name = parselib.GetFirstIdentifier(line[8:].strip()) if name is not None: rtags.AddFunction(taglib.Function(name, lnum)) elif line.startswith(u"procedure") and \ len(line) > 9 and line[9].isspace(): name = parselib.GetFirstIdentifier(line[9:].strip()) if name is not None: rtags.AddElement('procedure', taglib.Function(name, lnum, 'procedure')) elif line.startswith(u"#define") and \ len(line) > 7 and line[7].isspace(): 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 batch Script @param buff: a file like buffer object (StringIO) @todo: generate tags for batch tables? """ rtags = taglib.DocStruct() rtags.SetElementDescription('label', "Labels") rtags.SetElementDescription('section', "Labels") for lnum, line in enumerate(buff): line = line.strip() llen = len(line) # Skip comment and empty lines if (line.startswith(u"rem") and llen > 3 and line[3].isspace()) or not line: continue # Check for labels if line.startswith(u":"): name = parselib.GetFirstIdentifier(line[1:]) if name is not None: rtags.AddElement('label', taglib.Section(name, lnum)) return rtags
def GenerateTags(buff): """Create a DocStruct object that represents a Fortran @param buff: a file like buffer object (StringIO) """ rtags = taglib.DocStruct() rtags.SetElementDescription('pubfunct', "Public Functions") rtags.SetElementPriority('pubfunct', 4) rtags.SetElementDescription('function', "Functions") rtags.SetElementPriority('function', 3) rtags.SetElementDescription('pubsub', "Public Subroutines") rtags.SetElementPriority('pubsub', 2) rtags.SetElementDescription('subroutine', "Subroutines") rtags.SetElementPriority('subroutine', 1) for lnum, line in enumerate(buff): line = line.strip() # Skip comment and empty lines if line.startswith(u"'") or not line: continue # Temporary variables llen = len(line) tline = line.lower() # Check Subroutine, and Function Defs if tline.startswith(u'sub') and llen > 3 and line[3].isspace(): name = parselib.GetFirstIdentifier(line[3:].strip()) rtags.AddElement('sub', taglib.Function(name, lnum, 'subroutine')) elif tline.startswith( u'public sub') and llen > 10 and line[10].isspace(): name = parselib.GetFirstIdentifier(line[10:].strip()) rtags.AddElement('pubsub', taglib.Function(name, lnum, 'pubsub')) elif tline.startswith(u'function') and llen > 8 and line[8].isspace(): name = parselib.GetFirstIdentifier(line[8:].strip()) rtags.AddFunction(taglib.Function(name, lnum)) elif tline.startswith( u'public function') and llen > 15 and line[15].isspace(): name = parselib.GetFirstIdentifier(line[15:].strip()) rtags.AddElement('pubfunct', taglib.Function(name, lnum, 'pubfunct')) else: pass return rtags
def GetElementName(line): """Get the first element name on the given line, ignoring whitespace and language keywords. @param line: string @return: string or None """ for part in line.split(): name = parselib.GetFirstIdentifier(part) if name is not None and name not in FERITE_KW: return name else: continue return None
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 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
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 Cascading Style Sheets @param buff: a file like buffer object (StringIO) @todo: add support for parsing selectors and grouping classes and identities of each selector in a subscope. """ rtags = taglib.DocStruct() # Setup document structure # rtags.SetElementDescription('tag', "Selectors") # Use variables node for global identities rtags.SetElementDescription('variable', "Identities") # Use classes for global classes # Uses DocStruct builtin c_tag = None # Currenly found tag incomment = False # Inside a comment indef = False # Inside a style definition {} for lnum, line in enumerate(buff): line = line.strip() llen = len(line) idx = 0 while idx < len(line): # Skip Whitespace while line[idx].isspace(): idx += 1 # Check if valid item to add to document # if c_tag is not None and line[idx] == u'{': # rtags.AddElement('tag', c_tag) # c_tag = None # Check for coments if line[idx] == u'/' and llen > idx and line[idx + 1] == u'*': idx += 2 incomment = True elif line[idx] == u'*' and llen > idx and line[idx + 1] == 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 indef = True elif indef and line[idx] == u'}': idx += 1 indef = False elif not indef and line[idx] in (u'.', u'#'): if idx == 0 or line[idx - 1].isspace(): name = parselib.GetFirstIdentifier(line[idx + 1:]) if name is not None: name = line[idx] + name if line[idx] == u'.': rtags.AddClass(taglib.Class(name, lnum)) else: rtags.AddVariable(taglib.Variable(name, lnum)) idx += 1 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 an Editra Style Sheet @param buff: a file like buffer object (StringIO) """ rtags = taglib.DocStruct() rtags.SetElementDescription('styletag', "Style Tags") c_element = None # Currently found document element incomment = False # Inside a comment indef = False # Inside a style definition {} 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 if valid item to add to document if c_element is not None and line[idx] == u'{': rtags.AddElement('styletag', c_element) c_element = None # Check for coments if line[idx] == u'/' and llen > idx and line[idx+1] == u'*': idx += 2 incomment = True elif line[idx] == u'*' and llen > idx and line[idx+1] == 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 indef = True elif indef and line[idx] == u'}': idx += 1 indef = False elif not indef and line[idx].isalpha(): # Found start of tag name = parselib.GetFirstIdentifier(line[idx:]) if name is not None: # Make a tag but don't add it to the DocStruct till we # find if a { is the next non space character to follow c_element = StyleTag(name, lnum) idx += len(name) else: # This should never happen but if it does there must # be something wrong with the document or the parse has # gone afowl. idx += 1 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 style 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 += (len(line[idx:]) - len(line[idx:].lstrip())) # Check if in a <?php ?> block or not 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] in 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 line[idx:].startswith(u'class') \ and llen > idx + 5 and line[idx+5].isspace(): idx += 5 # Skip whitespace idx += (len(line[idx:]) - len(line[idx:].lstrip())) name = parselib.GetFirstIdentifier(line[idx:]) if name is not None: idx += len(name) # Move past the class name lastclass = taglib.Class(name, lnum) else: # Something must be wrong so skip ahead and keep going idx += 5 elif line[idx:].startswith( u'function') and llen > idx + 8 and line[idx + 8].isspace(): idx += 8 # Skip whitespace idx += (len(line[idx:]) - len(line[idx:].lstrip())) name = parselib.GetFirstIdentifier(line[idx:]) if name is not None: lastfun = name idx += len(name) # Skip whitespace idx += (len(line[idx:]) - len(line[idx:].lstrip())) 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 line[idx:].startswith(u'var') \ and llen > idx + 3 and line[idx+3].isspace(): # 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) elif line[idx] == u'=' and llen > idx + 1 and line[idx + 1] != u'=': break # jump to next line when we find an assigment else: idx += 1 return rtags