<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def _process_module(self, name, contents, parent, match, filepath=None):
 """Processes a regex match for a module to create a CodeElement."""

        #First, get hold of the name and contents of the module so that we can process the other
        #parts of the module.
        modifiers = []

        #We need to check for the private keyword before any type or contains declarations
        if self.RE_PRIV.search(contents):
            modifiers.append("private")
        #The only other modifier for modules ought to be implicit none
        if re.search("implicit\s+none", contents):
            modifiers.append("implicit none")

        #Next, parse out the dependencies of the module on other modules
        dependencies = self._parse_use(contents)
        publics, pubstart = self._process_publics(match.string)

        #We can now create the CodeElement
        result = Module(name, modifiers, dependencies, publics, contents, parent)
        if filepath is not None:
            result.filepath = filepath.lower()
        result.start = match.start()
        result.end = match.end()
        result.refstring = match.string
        result.set_public_start(pubstart)
        if self.RE_PRECOMP.search(contents):
            result.precompile = True

        self.xparser.parse(result)
        self.tparser.parse(result)

        #It is possible for the module to have members, parse those
        self._parse_members(contents, result)
        self.iparser.parse(result)

        #Now we can update the docstrings for the types. They rely on data
        #extracted during parse_members() which is why they have to run
        #separately over here.
        for t in result.types:
            self.tparser.update_docs(result.types[t], result)

        return result