def _deep_match(self, line, column):
        """Checks the contents of executables, types and modules for member
        definitions and updates the context."""
        #Now we just try each of the possibilities for the current line
        if self._match_member(line, column):
            self.el_section = "vars"
            self.el_type = ValueElement
            self.el_name = self.col_match.group("names")
            return
             
        if isinstance(self.element, Executable) or isinstance(self.element, Module):
            #We are inside of a subroutine or function definition
            #It is either params, vars or body. We already tested for variable
            #declarations in the match_member test. Check now to see if we are
            #on the line that defines the function
            self._match_exec(line)
            if self.col_match:
                self.el_section = "params"
                self.el_call = "assign"
                return

            #This regex incorrectly grabbing things like 'if' is functions because
            #they do actually like like functions... We need to filter the list 
            #with special keywords before we claim victory. TODO
            self.col_match = self.RE_DEPEND.match(self._source[line])
            if self.col_match:
                self.el_section = "body"
                self.el_name = self.col_match.group("exec")
                if self.col_match.group("sub") and "call" in self.col_match.group("sub"):
                    self.el_call = "sub"
                    self.el_type = Subroutine
                else:
                    self.el_call = "fun"
                    self.el_type = Function

                return
        #If we are inside a type, we either got the member variable declaration
        #already, or it is a pointer to a method inside of the module. Add the
        #test for that later. TODO
#        if isinstance(self.element, CustomType):
            
        self.el_section = "body"
        self.el_type = None
        #We just need to figure out what kind of a call is being made
        #at this column position, the only thing left is
        if " = " in self._source[line]:
            eqi = self._source[line].index("=")
            if column < eqi:
                self.el_call = "name"
            else:
                self.el_call = "assign"
            self.el_name = self._source[line].split("=")[0].strip()
        elif re.match("\s*call\s+", self._source[line]):
            self.el_call = "sub"
            self.el_name = self._source[line].split("call ")[1]
        else:
            #The only thing left (and the hardest to nail down) is
            #the arithmetic catch all type.
            self.el_call = "arith"
            self.el_name = "[arith]"
Checks the contents of executables, types and modules for member
        definitions and updates the context.