code: def _exec_check_pointers(executable):
      
      oparams = []
      pmembers = {}
      xassigns = map(lambda x: x.lower().strip(), executable.external_assignments())
  
      def add_offense(pname, member):
          """Adds the specified member as an offender under the specified parameter."""
          if pname not in oparams:
              oparams.append(pname)
          if pname not in pmembers:
              pmembers[pname] = [member]
          else:
              pmembers[pname].append(member)
  
      def check_buried(executable, pname, member):
          """Checks whether the member has its value changed by one of the dependency
          subroutines in the executable.
          """
          for d in executable.dependencies:
              if pname in d.argnames:
                  pindex = d.argnames.index(pname)
                  dtarget = d.target
                  if dtarget is not None:
                      mparam = dtarget.ordered_parameters[pindex]
              
      for pname, param in executable.parameters.items():
          if param.direction == "(out)" and param.is_custom:
              utype = param.customtype
              if utype is None:
                  continue
              for mname, member in utype.members.items():
                  key = "{}%{}".format(pname, mname).lower().strip()
                  if key not in xassigns:
                      #We also need to check the dependency calls to other, buried subroutines.
                      compname = "{}%{}".format(pname, mname).lower()
                      if executable.changed(compname) is None:
                          add_offense(pname, member)
                      
      return (oparams, pmembers)
docs: Checks the specified executable for the pointer condition that not
      all members of the derived type have had their values set.
  
      Returns (list of offending members, parameter name).