From a99dedfce29536ec156466b6846ef90dda46f1e2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tarek=20Ziad=C3=A9?= Date: Thu, 16 Jul 2009 15:35:45 +0000 Subject: [PATCH] #6466 refactored distutils duplicate get_versions() functions (used to get gcc/ld/dllwrap versions) --- Lib/distutils/cygwinccompiler.py | 42 ++++----- Lib/distutils/emxccompiler.py | 31 +++---- Lib/distutils/tests/test_cygwinccompiler.py | 83 +++++------------- Lib/distutils/tests/test_emxccompiler.py | 33 +++++++ Lib/distutils/tests/test_util.py | 97 ++++++++++++++++++++- Lib/distutils/util.py | 54 +++++++++++- Misc/NEWS | 5 ++ 7 files changed, 235 insertions(+), 110 deletions(-) create mode 100644 Lib/distutils/tests/test_emxccompiler.py diff --git a/Lib/distutils/cygwinccompiler.py b/Lib/distutils/cygwinccompiler.py index c35e49d713b..a8476e6579c 100644 --- a/Lib/distutils/cygwinccompiler.py +++ b/Lib/distutils/cygwinccompiler.py @@ -50,16 +50,15 @@ __revision__ = "$Id$" import os import sys import copy -from subprocess import Popen, PIPE import re +from warnings import warn from distutils.ccompiler import gen_preprocess_options, gen_lib_options from distutils.unixccompiler import UnixCCompiler from distutils.file_util import write_file from distutils.errors import DistutilsExecError, CompileError, UnknownFileError from distutils import log -from distutils.version import LooseVersion -from distutils.spawn import find_executable +from distutils.util import get_compiler_versions def get_msvcr(): """Include the appropriate MSVC runtime library if Python was built @@ -110,7 +109,7 @@ class CygwinCCompiler(UnixCCompiler): % details) self.gcc_version, self.ld_version, self.dllwrap_version = \ - get_versions() + get_compiler_versions() self.debug_print(self.compiler_type + ": gcc %s, ld %s, dllwrap %s\n" % (self.gcc_version, self.ld_version, @@ -359,31 +358,26 @@ def check_config_h(): return (CONFIG_H_UNCERTAIN, "couldn't read '%s': %s" % (fn, exc.strerror)) -RE_VERSION = re.compile('(\d+\.\d+(\.\d+)*)') +class _Deprecated_SRE_Pattern(object): + def __init__(self, pattern): + self.pattern = pattern -def _find_exe_version(cmd): - """Find the version of an executable by running `cmd` in the shell. + def __getattr__(self, name): + if name in ('findall', 'finditer', 'match', 'scanner', 'search', + 'split', 'sub', 'subn'): + warn("'distutils.cygwinccompiler.RE_VERSION' is deprecated " + "and will be removed in the next version", DeprecationWarning) + return getattr(self.pattern, name) - If the command is not found, or the output does not match - `RE_VERSION`, returns None. - """ - executable = cmd.split()[0] - if find_executable(executable) is None: - return None - out = Popen(cmd, shell=True, stdout=PIPE).stdout - try: - out_string = out.read() - finally: - out.close() - result = RE_VERSION.search(out_string) - if result is None: - return None - return LooseVersion(result.group(1)) +RE_VERSION = _Deprecated_SRE_Pattern(re.compile('(\d+\.\d+(\.\d+)*)')) def get_versions(): """ Try to find out the versions of gcc, ld and dllwrap. If not possible it returns None for it. """ - commands = ['gcc -dumpversion', 'ld -v', 'dllwrap --version'] - return tuple([_find_exe_version(cmd) for cmd in commands]) + warn("'distutils.cygwinccompiler.get_versions' is deprecated " + "use 'distutils.util.get_compiler_versions' instead", + DeprecationWarning) + + return get_compiler_versions() diff --git a/Lib/distutils/emxccompiler.py b/Lib/distutils/emxccompiler.py index f52e63232db..a5a2ef88fe0 100644 --- a/Lib/distutils/emxccompiler.py +++ b/Lib/distutils/emxccompiler.py @@ -21,12 +21,15 @@ handles the EMX port of the GNU C compiler to OS/2. __revision__ = "$Id$" -import os,sys,copy +import os, sys, copy +from warnings import warn + from distutils.ccompiler import gen_preprocess_options, gen_lib_options from distutils.unixccompiler import UnixCCompiler from distutils.file_util import write_file from distutils.errors import DistutilsExecError, CompileError, UnknownFileError from distutils import log +from distutils.util import get_compiler_versions class EMXCCompiler (UnixCCompiler): @@ -55,8 +58,8 @@ class EMXCCompiler (UnixCCompiler): ("Reason: %s." % details) + "Compiling may fail because of undefined preprocessor macros.") - (self.gcc_version, self.ld_version) = \ - get_versions() + gcc_version, ld_version, dllwrap_version = get_compiler_versions() + self.gcc_version, self.ld_version = gcc_version, ld_version self.debug_print(self.compiler_type + ": gcc %s, ld %s\n" % (self.gcc_version, self.ld_version) ) @@ -293,23 +296,11 @@ def get_versions(): """ Try to find out the versions of gcc and ld. If not possible it returns None for it. """ - from distutils.version import StrictVersion - from distutils.spawn import find_executable - import re + warn("'distutils.emxccompiler.get_versions' is deprecated " + "use 'distutils.util.get_compiler_versions' instead", + DeprecationWarning) - gcc_exe = find_executable('gcc') - if gcc_exe: - out = os.popen(gcc_exe + ' -dumpversion','r') - out_string = out.read() - out.close() - result = re.search('(\d+\.\d+\.\d+)',out_string) - if result: - gcc_version = StrictVersion(result.group(1)) - else: - gcc_version = None - else: - gcc_version = None # EMX ld has no way of reporting version number, and we use GCC # anyway - so we can link OMF DLLs - ld_version = None - return (gcc_version, ld_version) + gcc_version, ld_version, dllwrap_version = get_compiler_versions() + return gcc_version, None diff --git a/Lib/distutils/tests/test_cygwinccompiler.py b/Lib/distutils/tests/test_cygwinccompiler.py index fb823e4d801..b54ffff3617 100644 --- a/Lib/distutils/tests/test_cygwinccompiler.py +++ b/Lib/distutils/tests/test_cygwinccompiler.py @@ -2,28 +2,19 @@ import unittest import sys import os -from StringIO import StringIO -import subprocess +import warnings + +from test.test_support import check_warnings +from test.test_support import captured_stdout from distutils import cygwinccompiler from distutils.cygwinccompiler import (CygwinCCompiler, check_config_h, CONFIG_H_OK, CONFIG_H_NOTOK, CONFIG_H_UNCERTAIN, get_versions, - get_msvcr) + get_msvcr, RE_VERSION) +from distutils.util import get_compiler_versions from distutils.tests import support -class FakePopen(object): - test_class = None - - def __init__(self, cmd, shell, stdout): - self.cmd = cmd.split()[0] - exes = self.test_class._exes - if self.cmd in exes: - self.stdout = StringIO(exes[self.cmd]) - else: - self.stdout = os.popen(cmd, 'r') - - class CygwinCCompilerTestCase(support.TempdirManager, unittest.TestCase): @@ -34,29 +25,16 @@ class CygwinCCompilerTestCase(support.TempdirManager, from distutils import sysconfig self.old_get_config_h_filename = sysconfig.get_config_h_filename sysconfig.get_config_h_filename = self._get_config_h_filename - self.old_find_executable = cygwinccompiler.find_executable - cygwinccompiler.find_executable = self._find_executable - self._exes = {} - self.old_popen = cygwinccompiler.Popen - FakePopen.test_class = self - cygwinccompiler.Popen = FakePopen def tearDown(self): sys.version = self.version from distutils import sysconfig sysconfig.get_config_h_filename = self.old_get_config_h_filename - cygwinccompiler.find_executable = self.old_find_executable - cygwinccompiler.Popen = self.old_popen super(CygwinCCompilerTestCase, self).tearDown() def _get_config_h_filename(self): return self.python_h - def _find_executable(self, name): - if name in self._exes: - return name - return None - def test_check_config_h(self): # check_config_h looks for "GCC" in sys.version first @@ -80,40 +58,6 @@ class CygwinCCompilerTestCase(support.TempdirManager, self.write_file(self.python_h, 'xxx __GNUC__ xxx') self.assertEquals(check_config_h()[0], CONFIG_H_OK) - def test_get_versions(self): - - # get_versions calls distutils.spawn.find_executable on - # 'gcc', 'ld' and 'dllwrap' - self.assertEquals(get_versions(), (None, None, None)) - - # Let's fake we have 'gcc' and it returns '3.4.5' - self._exes['gcc'] = 'gcc (GCC) 3.4.5 (mingw special)\nFSF' - res = get_versions() - self.assertEquals(str(res[0]), '3.4.5') - - # and let's see what happens when the version - # doesn't match the regular expression - # (\d+\.\d+(\.\d+)*) - self._exes['gcc'] = 'very strange output' - res = get_versions() - self.assertEquals(res[0], None) - - # same thing for ld - self._exes['ld'] = 'GNU ld version 2.17.50 20060824' - res = get_versions() - self.assertEquals(str(res[1]), '2.17.50') - self._exes['ld'] = '@(#)PROGRAM:ld PROJECT:ld64-77' - res = get_versions() - self.assertEquals(res[1], None) - - # and dllwrap - self._exes['dllwrap'] = 'GNU dllwrap 2.17.50 20060824\nFSF' - res = get_versions() - self.assertEquals(str(res[2]), '2.17.50') - self._exes['dllwrap'] = 'Cheese Wrap' - res = get_versions() - self.assertEquals(res[2], None) - def test_get_msvcr(self): # none @@ -146,6 +90,21 @@ class CygwinCCompilerTestCase(support.TempdirManager, '[MSC v.1999 32 bits (Intel)]') self.assertRaises(ValueError, get_msvcr) + + def test_get_version_deprecated(self): + with check_warnings() as w: + warnings.simplefilter("always") + # make sure get_compiler_versions and get_versions + # returns the same thing + self.assertEquals(get_compiler_versions(), get_versions()) + # make sure using get_version() generated a warning + self.assertEquals(len(w.warnings), 1) + # make sure any usage of RE_VERSION will also + # generate a warning, but till works + version = RE_VERSION.search('1.2').group(1) + self.assertEquals(version, '1.2') + self.assertEquals(len(w.warnings), 2) + def test_suite(): return unittest.makeSuite(CygwinCCompilerTestCase) diff --git a/Lib/distutils/tests/test_emxccompiler.py b/Lib/distutils/tests/test_emxccompiler.py new file mode 100644 index 00000000000..6e1deced35b --- /dev/null +++ b/Lib/distutils/tests/test_emxccompiler.py @@ -0,0 +1,33 @@ +"""Tests for distutils.emxccompiler.""" +import unittest +import sys +import os +import warnings + +from test.test_support import check_warnings +from test.test_support import captured_stdout + +from distutils.emxccompiler import get_versions +from distutils.util import get_compiler_versions +from distutils.tests import support + +class EmxCCompilerTestCase(support.TempdirManager, + unittest.TestCase): + + def test_get_version_deprecated(self): + with check_warnings() as w: + warnings.simplefilter("always") + # make sure get_compiler_versions and get_versions + # returns the same gcc + gcc, ld, dllwrap = get_compiler_versions() + emx_gcc, emx_ld = get_versions() + self.assertEquals(gcc, emx_gcc) + + # make sure using get_version() generated a warning + self.assertEquals(len(w.warnings), 1) + +def test_suite(): + return unittest.makeSuite(EmxCCompilerTestCase) + +if __name__ == '__main__': + test_support.run_unittest(test_suite()) diff --git a/Lib/distutils/tests/test_util.py b/Lib/distutils/tests/test_util.py index c0acf5f4814..ffa92bd07e1 100644 --- a/Lib/distutils/tests/test_util.py +++ b/Lib/distutils/tests/test_util.py @@ -6,15 +6,33 @@ import os import sys import unittest from copy import copy +from StringIO import StringIO +import subprocess from distutils.errors import DistutilsPlatformError from distutils.util import (get_platform, convert_path, change_root, check_environ, split_quoted, strtobool, - rfc822_escape) -from distutils import util # used to patch _environ_checked + rfc822_escape, get_compiler_versions, + _find_exe_version, _MAC_OS_X_LD_VERSION) +from distutils import util from distutils.sysconfig import get_config_vars from distutils import sysconfig from distutils.tests import support +from distutils.version import LooseVersion + +class FakePopen(object): + test_class = None + def __init__(self, cmd, shell, stdout, stderr): + self.cmd = cmd.split()[0] + exes = self.test_class._exes + if self.cmd not in exes: + # we don't want to call the system, returning an empty + # output so it doesn't match + self.stdout = StringIO() + self.stderr = StringIO() + else: + self.stdout = StringIO(exes[self.cmd]) + self.stderr = StringIO() class UtilTestCase(support.EnvironGuard, unittest.TestCase): @@ -37,9 +55,16 @@ class UtilTestCase(support.EnvironGuard, unittest.TestCase): else: self.uname = None self._uname = None - os.uname = self._get_uname + # patching POpen + self.old_find_executable = util.find_executable + util.find_executable = self._find_executable + self._exes = {} + self.old_popen = subprocess.Popen + FakePopen.test_class = self + subprocess.Popen = FakePopen + def tearDown(self): # getting back the environment os.name = self.name @@ -54,6 +79,8 @@ class UtilTestCase(support.EnvironGuard, unittest.TestCase): else: del os.uname sysconfig._config_vars = copy(self._config_vars) + util.find_executable = self.old_find_executable + subprocess.Popen = self.old_popen super(UtilTestCase, self).tearDown() def _set_uname(self, uname): @@ -237,6 +264,70 @@ class UtilTestCase(support.EnvironGuard, unittest.TestCase): 'header%(8s)s') % {'8s': '\n'+8*' '} self.assertEquals(res, wanted) + def test_find_exe_version(self): + # the ld version scheme under MAC OS is: + # ^@(#)PROGRAM:ld PROJECT:ld64-VERSION + # + # where VERSION is a 2-digit number for major + # revisions. For instance under Leopard, it's + # currently 77 + # + # Dots are used when branching is done. + # + # The SnowLeopard ld64 is currently 95.2.12 + + for output, version in (('@(#)PROGRAM:ld PROJECT:ld64-77', '77'), + ('@(#)PROGRAM:ld PROJECT:ld64-95.2.12', + '95.2.12')): + result = _MAC_OS_X_LD_VERSION.search(output) + self.assertEquals(result.group(1), version) + + def _find_executable(self, name): + if name in self._exes: + return name + return None + + def test_get_compiler_versions(self): + # get_versions calls distutils.spawn.find_executable on + # 'gcc', 'ld' and 'dllwrap' + self.assertEquals(get_compiler_versions(), (None, None, None)) + + # Let's fake we have 'gcc' and it returns '3.4.5' + self._exes['gcc'] = 'gcc (GCC) 3.4.5 (mingw special)\nFSF' + res = get_compiler_versions() + self.assertEquals(str(res[0]), '3.4.5') + + # and let's see what happens when the version + # doesn't match the regular expression + # (\d+\.\d+(\.\d+)*) + self._exes['gcc'] = 'very strange output' + res = get_compiler_versions() + self.assertEquals(res[0], None) + + # same thing for ld + if sys.platform != 'darwin': + self._exes['ld'] = 'GNU ld version 2.17.50 20060824' + res = get_compiler_versions() + self.assertEquals(str(res[1]), '2.17.50') + self._exes['ld'] = '@(#)PROGRAM:ld PROJECT:ld64-77' + res = get_compiler_versions() + self.assertEquals(res[1], None) + else: + self._exes['ld'] = 'GNU ld version 2.17.50 20060824' + res = get_compiler_versions() + self.assertEquals(res[1], None) + self._exes['ld'] = '@(#)PROGRAM:ld PROJECT:ld64-77' + res = get_compiler_versions() + self.assertEquals(str(res[1]), '77') + + # and dllwrap + self._exes['dllwrap'] = 'GNU dllwrap 2.17.50 20060824\nFSF' + res = get_compiler_versions() + self.assertEquals(str(res[2]), '2.17.50') + self._exes['dllwrap'] = 'Cheese Wrap' + res = get_compiler_versions() + self.assertEquals(res[2], None) + def test_suite(): return unittest.makeSuite(UtilTestCase) diff --git a/Lib/distutils/util.py b/Lib/distutils/util.py index 5bbbf225602..459c36462d9 100644 --- a/Lib/distutils/util.py +++ b/Lib/distutils/util.py @@ -7,10 +7,12 @@ one of the other *util.py modules. __revision__ = "$Id$" import sys, os, string, re + from distutils.errors import DistutilsPlatformError from distutils.dep_util import newer -from distutils.spawn import spawn +from distutils.spawn import spawn, find_executable from distutils import log +from distutils.version import LooseVersion def get_platform(): """Return a string that identifies the current platform. @@ -539,3 +541,53 @@ def rfc822_escape(header): lines = [x.strip() for x in header.split('\n')] sep = '\n' + 8*' ' return sep.join(lines) + +_RE_VERSION = re.compile('(\d+\.\d+(\.\d+)*)') +_MAC_OS_X_LD_VERSION = re.compile('^@\(#\)PROGRAM:ld PROJECT:ld64-((\d+)(\.\d+)*)') + +def _find_ld_version(): + """Finds the ld version. The version scheme differs under Mac OSX.""" + if sys.platform == 'darwin': + return _find_exe_version('ld -v', _MAC_OS_X_LD_VERSION) + else: + return _find_exe_version('ld -v') + +def _find_exe_version(cmd, pattern=_RE_VERSION): + """Find the version of an executable by running `cmd` in the shell. + + `pattern` is a compiled regular expression. If not provided, default + to _RE_VERSION. If the command is not found, or the output does not + match the mattern, returns None. + """ + from subprocess import Popen, PIPE + executable = cmd.split()[0] + if find_executable(executable) is None: + return None + pipe = Popen(cmd, shell=True, stdout=PIPE, stderr=PIPE) + try: + stdout, stderr = pipe.stdout.read(), pipe.stderr.read() + finally: + pipe.stdout.close() + pipe.stderr.close() + # some commands like ld under MacOS X, will give the + # output in the stderr, rather than stdout. + if stdout != '': + out_string = stdout + else: + out_string = stderr + + result = pattern.search(out_string) + if result is None: + return None + return LooseVersion(result.group(1)) + +def get_compiler_versions(): + """Returns a tuple providing the versions of gcc, ld and dllwrap + + For each command, if a command is not found, None is returned. + Otherwise a LooseVersion instance is returned. + """ + gcc = _find_exe_version('gcc -dumpversion') + ld = _find_ld_version() + dllwrap = _find_exe_version('dllwrap --version') + return gcc, ld, dllwrap diff --git a/Misc/NEWS b/Misc/NEWS index 3e43df58e51..9d34adfc2b9 100644 --- a/Misc/NEWS +++ b/Misc/NEWS @@ -352,6 +352,11 @@ Core and Builtins Library ------- +- Issue #6466: now distutils.cygwinccompiler and distutils.emxccompiler + uses the same refactored function to get gcc/ld/dllwrap versions numbers. + It's `distutils.util.get_compiler_versions`. Added deprecation warnings + for the obsolete get_versions() functions. + - Issue #6433: fixed issues with multiprocessing.pool.map hanging on empty list - Issue #6314: logging: Extra checks on the "level" argument in more places.