def check_config(self, logger):
        """
        Perform optional error checks.

        Parameters
        ----------
        logger : object
            The object that manages logging output.
        """
        # check for the command
        comp = self._comp

        cmd = [c for c in comp.options['command'] if c.strip()]
        if not cmd:
            logger.error("The command cannot be empty")
        else:
            program_to_execute = comp.options['command'][0]
            if sys.platform == 'win32':
                if not find_executable(program_to_execute):
                    missing = self._check_for_files([program_to_execute])
                    if missing:
                        logger.error("The command to be executed, '%s', "
                                     "cannot be found" % program_to_execute)
            else:
                if not find_executable(program_to_execute):
                    logger.error("The command to be executed, '%s', "
                                 "cannot be found" % program_to_execute)

        # Check for missing input files. This just generates a warning during
        # setup, since these files may be generated later during execution.
        missing = self._check_for_files(comp.options['external_input_files'])
        if missing:
            logger.warning("The following input files are missing at setup "
                           "time: %s" % missing)

    def get_version(self,*args,**kwds):
        version = FCompiler.get_version(self,*args,**kwds)

        if version is None and sys.platform.startswith('aix'):
            # use lslpp to find out xlf version
            lslpp = find_executable('lslpp')
            xlf = find_executable('xlf')
            if os.path.exists(xlf) and os.path.exists(lslpp):
                s,o = exec_command(lslpp + ' -Lc xlfcmp')
                m = re.search('xlfcmp:(?P<version>\d+([.]\d+)+)', o)
                if m: version = m.group('version')

        xlf_dir = '/etc/opt/ibmcmp/xlf'
        if version is None and os.path.isdir(xlf_dir):
            # linux:
            # If the output of xlf does not contain version info
            # (that's the case with xlf 8.1, for instance) then
            # let's try another method:
            l = os.listdir(xlf_dir)
            l.sort()
            l.reverse()
            l = [d for d in l if os.path.isfile(os.path.join(xlf_dir,d,'xlf.cfg'))]
            if l:
                from distutils.version import LooseVersion
                self.version = version = LooseVersion(l[0])
        return version

    def _execute_local(self, command):
        """
        Run the command.

        Parameters
        ----------
        command : List
            List containing OS command string.

        Returns
        -------
        int
            Return Code
        str
            Error Message
        """
        # Check to make sure command exists
        comp = self._comp

        if isinstance(command, str):
            program_to_execute = command
        else:
            program_to_execute = command[0]

        # Suppress message from find_executable function, we'll handle it
        numpy.distutils.log.set_verbosity(-1)

        if sys.platform == 'win32':
            if not find_executable(program_to_execute):
                missing = self._check_for_files([program_to_execute])
                if missing:
                    raise ValueError("The command to be executed, '%s', "
                                     "cannot be found" % program_to_execute)
            command_for_shell_proc = ['cmd.exe', '/c'] + command
        else:
            if not find_executable(program_to_execute):
                raise ValueError("The command to be executed, '%s', "
                                 "cannot be found" % program_to_execute)
            command_for_shell_proc = command

        comp._process = \
            ShellProc(command_for_shell_proc, comp.stdin,
                      comp.stdout, comp.stderr, comp.options['env_vars'])

        try:
            return_code, error_msg = \
                comp._process.wait(comp.options['poll_delay'], comp.options['timeout'])
        finally:
            comp._process.close_files()
            comp._process = None

        return (return_code, error_msg)

    def check_setup(self, out_stream=sys.stdout):
        """Write a report to the given stream indicating any potential problems found
        with the current configuration of this ``Problem``.

        Args
        ----
        out_stream : a file-like object, optional
        """

        # check for the command
        if not self.options['command']:
            out_stream.write( "The command cannot be empty")
        else:
            if isinstance(self.options['command'], str):
                program_to_execute = self.options['command']
            else:
                program_to_execute = self.options['command'][0]
            command_full_path = find_executable( program_to_execute )

            if not command_full_path:
                msg = "The command to be executed, '%s', cannot be found" % program_to_execute
                out_stream.write(msg)

        # Check for missing input files
        missing_files = self._check_for_files(input=True)
        for iotype, path in missing_files:
            msg = "The %s file %s is missing" % ( iotype, path )
            out_stream.write(msg)

    def _execute_local(self):
        """ Run command. """

        # check to make sure command exists
        if isinstance(self.options['command'], str):
            program_to_execute = self.options['command']
        else:
            program_to_execute = self.options['command'][0]

        # suppress message from find_executable function, we'll handle it
        numpy.distutils.log.set_verbosity(-1)

        command_full_path = find_executable( program_to_execute )
        if not command_full_path:
            raise ValueError("The command to be executed, '%s', cannot be found" % program_to_execute)

        command_for_shell_proc = self.options['command']
        if sys.platform == 'win32':
            command_for_shell_proc = ['cmd.exe', '/c' ] + command_for_shell_proc

        self._process = \
            ShellProc(command_for_shell_proc, self.stdin,
                      self.stdout, self.stderr, self.options['env_vars'])

        try:
            return_code, error_msg = \
                self._process.wait(self.options['poll_delay'], self.options['timeout'])
        finally:
            self._process.close_files()
            self._process = None

        return (return_code, error_msg)

    def check_setup(self, out_stream=sys.stdout):
        """Write a report to the given stream indicating any potential problems found
        with the current configuration of this ``Problem``.

        Args
        ----
        out_stream : a file-like object, optional
        """

        # check for the command
        cmd = [c for c in self.options['command'] if c.strip()]
        if not cmd:
            out_stream.write( "The command cannot be empty")
        else:
            program_to_execute = self.options['command'][0]
            command_full_path = find_executable( program_to_execute )

            if not command_full_path:
                out_stream.write("The command to be executed, '%s', "
                                 "cannot be found" % program_to_execute)

        # Check for missing input files
        missing = self._check_for_files(self.options['external_input_files'])
        if missing:
            out_stream.write("The following input files are missing at setup "
                             " time: %s" % missing)

 def find_executables(self):
     for fc_exe in [find_executable(c) for c in ['gfortran','f95']]:
         if os.path.isfile(fc_exe):
             break
     for key in ['version_cmd', 'compiler_f77', 'compiler_f90',
                 'compiler_fix', 'linker_so', 'linker_exe']:
         self.executables[key][0] = fc_exe

 def build_libraries(self, libraries):
     if parse_version(numpy.__version__) < parse_version('1.7'):
         fcompiler = self.fcompiler
     else:
         fcompiler = self._f_compiler
     if isinstance(fcompiler,
                   numpy.distutils.fcompiler.gnu.Gnu95FCompiler):
         old_value = numpy.distutils.log.set_verbosity(-2)
         exe = find_executable('gcc-ar')
         if exe is None:
             exe = find_executable('ar')
         numpy.distutils.log.set_verbosity(old_value)
         self.compiler.archiver[0] = exe
         flags = F77_COMPILE_ARGS_GFORTRAN + F77_COMPILE_OPT_GFORTRAN
         if self.debug:
             flags += F77_COMPILE_DEBUG_GFORTRAN
         if F77_OPENMP:
             flags += ['-openmp']
         fcompiler.executables['compiler_f77'] += flags
         flags = F90_COMPILE_ARGS_GFORTRAN + F90_COMPILE_OPT_GFORTRAN
         if self.debug:
             flags += F90_COMPILE_DEBUG_GFORTRAN
         if F90_OPENMP:
             flags += ['-openmp']
         fcompiler.executables['compiler_f90'] += flags
         fcompiler.libraries += [LIBRARY_OPENMP_GFORTRAN]
     elif isinstance(fcompiler,
                     numpy.distutils.fcompiler.intel.IntelFCompiler):
         old_value = numpy.distutils.log.set_verbosity(-2)
         self.compiler.archiver[0] = find_executable('xiar')
         numpy.distutils.log.set_verbosity(old_value)
         flags = F77_COMPILE_ARGS_IFORT + F77_COMPILE_OPT_IFORT
         if self.debug:
             flags += F77_COMPILE_DEBUG_IFORT
         if F77_OPENMP:
             flags += ['-openmp']
         fcompiler.executables['compiler_f77'] += flags
         flags = F90_COMPILE_ARGS_IFORT + F90_COMPILE_OPT_IFORT
         if self.debug:
             flags += F90_COMPILE_DEBUG_IFORT
         if F90_OPENMP:
             flags += ['-openmp']
         fcompiler.executables['compiler_f90'] += flags
         fcompiler.libraries += [LIBRARY_OPENMP_IFORT]
     else:
         raise RuntimeError("Unhandled compiler: '{}'.".format(fcompiler))
     build_clib.build_libraries(self, libraries)

def get_cxx_tool_path(compiler):
    """Given a distutils.ccompiler.CCompiler class, returns the path of the
    toolset related to C compilation."""
    fullpath_exec = find_executable(get_cxxcompiler_executable(compiler))
    if fullpath_exec:
        fullpath = pdirname(fullpath_exec)
    else:
        raise DistutilsSetupError("Could not find compiler executable info for scons")
    return fullpath

 def finalize_options(self):
     build.finalize_options(self)
     self.help2man = find_executable('help2man')
     if not self.help2man:
         raise DistutilsSetupError('Building man pages requires help2man.')

 def cached_find_executable(exe):
     if exe in exe_cache:
         return exe_cache[exe]
     fc_exe = find_executable(exe)
     exe_cache[exe] = exe_cache[fc_exe] = fc_exe
     return fc_exe