Пример #1
0
    def parseTags(self, code_lines):
        """Parse all the tokens found in the lines of code"""
        container_list = []
        vset = set()

        for num, line in code_lines:
            try:
                # Subroutine
                if parselib.HasToken(line, Token.Keyword, "sub"):
                    fname = parselib.GetTokenValue(line, Token.Name.Function)
                    self.rtags.AddElement(
                        'subroutine', taglib.Function(fname, num,
                                                      "subroutine"))

                # Packages
                if parselib.HasToken(line, Token.Name.Builtin, "package"):
                    name = None
                    next = True
                    for token, value in line:
                        if not next:
                            name += value
                            break

                        if token == Token.Name.Namespace:
                            name = value
                            next = False

                    if name is not None:
                        self.rtags.AddElement('package',
                                              taglib.Package(name, num))

            except parselib.TokenNotFound:
                pass
Пример #2
0
def GenerateTags(buff):
    """Create a DocStruct object that represents a Perl Script
    @param buff: a file like buffer object (StringIO)

    """
    rtags = taglib.DocStruct()
    rtags.SetElementDescription('package', "Packages")
    rtags.SetElementPriority('package', 3)
    rtags.SetElementDescription('subdec', "Subroutine Declarations")
    rtags.SetElementPriority('subdec', 2)
    rtags.SetElementDescription('subroutine', "Subroutines")
    rtags.SetElementPriority('subroutine', 1)
    inpod = False

    for lnum, line in enumerate(buff):
        # Check for POD docs and skip as necessary
        if line.startswith(u"=") and len(line) > 2:
            if line.startswith(u"=cut"):
                inpod = False
            elif line[1].isalpha():
                inpod = True
            continue

        if inpod:
            continue

        # Not in POD so try to parse for elements
        line = line.strip()
        llen = len(line)

        # Skip comment and empty lines
        if line.startswith(u"#") or not line:
            continue

        # Check for subroutines
        if parselib.IsToken(line, 0, u'sub'):
            sub = ExtractSubroutine(line)
            if sub is not None:
                if sub[0]:
                    rtags.AddElement('subdec',
                                     taglib.Function(sub[1], lnum, "subdec"))
                else:
                    rtags.AddElement('subroutine',
                                     taglib.Function(sub[1], lnum, "subroutine"))
        elif parselib.IsToken(line, 0, u'package'):
            # Look for a package declaration
            parts = line.split()
            if line.endswith(u";") and len(parts) <= 3:
                name = parts[1].rstrip(u";")
                rtags.AddElement('package', taglib.Package(name, lnum))
        else:
            pass

    return rtags
Пример #3
0
def GetPackage(line, lnum):
    """Get a package object from the current line
    @precondition: line has a package def on it

    """
    package = None
    parts = line.split()
    # package require name version
    if len(parts) >= 3:
        name = u" ".join(parts[2:])
        package = taglib.Package(name, lnum)
    return package
Пример #4
0
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