code: def _process_module(self, name, contents, parent, match, filepath=None):
          
          #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
docs: Processes a regex match for a module to create a CodeElement.