Extracts any module-level members from the code. They must appear before
        any type declalations.

def _parse_members(self, contents, module):
        """Extracts any module-level members from the code. They must appear before
        any type declalations."""
        #We need to get hold of the text before the module's main CONTAINS keyword
        #so that we don't find variables from executables and claim them as
        #belonging to the module.
        icontains = module.contains_index
        ichar = module.charindex(icontains, 0)
        module.preamble = module.refstring[:ichar]

        #Get a dictionary of all the members in this module body
        #We only want to look at variable definitions before the first type
        lowest = ichar
        remove = [] #Will use later below, see next comment
        for t in module.types:
            remove.append((module.types[t].start, module.types[t].end))
            if module.types[t].start < lowest:
                lowest = module.types[t].start

        module.members.update(self.vparser.parse(contents[:lowest-(module.start + 10 + len(module.name))], module))

        #The docstrings for these members will appear as member tags in the same
        #preamble text. We can't use the entire preamble for this because member
        #docs inside of a type declaration will show up as belonging to the
        #module, when in fact, they don't.
        remove.sort(key=lambda tup: tup[0])
        retain = []
        cur_end = 0
        for rem in remove:
            signature = module.refstring[rem[0]+1:rem[1]].index("\n") + 2
            keep = module.refstring[cur_end:rem[0] + signature]
            cur_end = rem[1]
            retain.append(keep)

        #If there weren't any types in the module, we still want to get at the docs in
        #the preamble.
        if len(remove) == 0:
            retain = module.preamble

        docsearch = "".join(retain)
        module.predocs = self.docparser.parse_docs(docsearch, module)
        if module.name in module.predocs:
            #We can only do member docstrings if the module had internal docstrings
            #that may  to members.
            memdocs = self.docparser.to_doc(module.predocs[module.name][0], module.name)
            remainingdocs = self.docparser.process_memberdocs(memdocs, module)
            module.predocs[module.name] = remainingdocs