Lib/platform.py

   1 #!/usr/bin/env python
   2
   3 """ This module tries to retrieve as much platform-identifying data as
   4     possible. It makes this information available via function APIs.
   5
   6     If called from the command line, it prints the platform
   7     information concatenated as single string to stdout. The output
   8     format is useable as part of a filename.
   9
  10 """
  11 #    This module is maintained by Marc-Andre Lemburg <mal@egenix.com>.
  12 #    If you find problems, please submit bug reports/patches via the
  13 #    Python SourceForge Project Page and assign them to "lemburg".
  14 #
  15 #    Note: Please keep this module compatible to Python 1.5.2.
  16 #
  17 #    Still needed:
  18 #    * more support for WinCE
  19 #    * support for MS-DOS (PythonDX ?)
  20 #    * support for Amiga and other still unsupported platforms running Python
  21 #    * support for additional Linux distributions
  22 #
  23 #    Many thanks to all those who helped adding platform-specific
  24 #    checks (in no particular order):
  25 #
  26 #      Charles G Waldman, David Arnold, Gordon McMillan, Ben Darnell,
  27 #      Jeff Bauer, Cliff Crawford, Ivan Van Laningham, Josef
  28 #      Betancourt, Randall Hopper, Karl Putland, John Farrell, Greg
  29 #      Andruk, Just van Rossum, Thomas Heller, Mark R. Levinson, Mark
  30 #      Hammond, Bill Tutt, Hans Nowak, Uwe Zessin (OpenVMS support),
  31 #      Colin Kong, Trent Mick, Guido van Rossum, Anthony Baxter
  32 #
  33 #    History:
  34 #
  35 #    <see CVS and SVN checkin messages for history>
  36 #
  37 #    1.0.6 - added linux_distribution()
  38 #    1.0.5 - fixed Java support to allow running the module on Jython
  39 #    1.0.4 - added IronPython support
  40 #    1.0.3 - added normalization of Windows system name
  41 #    1.0.2 - added more Windows support
  42 #    1.0.1 - reformatted to make doc.py happy
  43 #    1.0.0 - reformatted a bit and checked into Python CVS
  44 #    0.8.0 - added sys.version parser and various new access
  45 #            APIs (python_version(), python_compiler(), etc.)
  46 #    0.7.2 - fixed architecture() to use sizeof(pointer) where available
  47 #    0.7.1 - added support for Caldera OpenLinux
  48 #    0.7.0 - some fixes for WinCE; untabified the source file
  49 #    0.6.2 - support for OpenVMS - requires version 1.5.2-V006 or higher and
  50 #            vms_lib.getsyi() configured
  51 #    0.6.1 - added code to prevent 'uname -p' on platforms which are
  52 #            known not to support it
  53 #    0.6.0 - fixed win32_ver() to hopefully work on Win95,98,NT and Win2k;
  54 #            did some cleanup of the interfaces - some APIs have changed
  55 #    0.5.5 - fixed another type in the MacOS code... should have
  56 #            used more coffee today ;-)
  57 #    0.5.4 - fixed a few typos in the MacOS code
  58 #    0.5.3 - added experimental MacOS support; added better popen()
  59 #            workarounds in _syscmd_ver() -- still not 100% elegant
  60 #            though
  61 #    0.5.2 - fixed uname() to return '' instead of 'unknown' in all
  62 #            return values (the system uname command tends to return
  63 #            'unknown' instead of just leaving the field emtpy)
  64 #    0.5.1 - included code for slackware dist; added exception handlers
  65 #            to cover up situations where platforms don't have os.popen
  66 #            (e.g. Mac) or fail on socket.gethostname(); fixed libc
  67 #            detection RE
  68 #    0.5.0 - changed the API names referring to system commands to *syscmd*;
  69 #            added java_ver(); made syscmd_ver() a private
  70 #            API (was system_ver() in previous versions) -- use uname()
  71 #            instead; extended the win32_ver() to also return processor
  72 #            type information
  73 #    0.4.0 - added win32_ver() and modified the platform() output for WinXX
  74 #    0.3.4 - fixed a bug in _follow_symlinks()
  75 #    0.3.3 - fixed popen() and "file" command invokation bugs
  76 #    0.3.2 - added architecture() API and support for it in platform()
  77 #    0.3.1 - fixed syscmd_ver() RE to support Windows NT
  78 #    0.3.0 - added system alias support
  79 #    0.2.3 - removed 'wince' again... oh well.
  80 #    0.2.2 - added 'wince' to syscmd_ver() supported platforms
  81 #    0.2.1 - added cache logic and changed the platform string format
  82 #    0.2.0 - changed the API to use functions instead of module globals
  83 #            since some action take too long to be run on module import
  84 #    0.1.0 - first release
  85 #
  86 #    You can always get the latest version of this module at:
  87 #
  88 #             http://www.egenix.com/files/python/platform.py
  89 #
  90 #    If that URL should fail, try contacting the author.
  91
  92 __copyright__ = """
  93     Copyright (c) 1999-2000, Marc-Andre Lemburg; mailto:mal@lemburg.com
  94     Copyright (c) 2000-2007, eGenix.com Software GmbH; mailto:info@egenix.com
  95
  96     Permission to use, copy, modify, and distribute this software and its
  97     documentation for any purpose and without fee or royalty is hereby granted,
  98     provided that the above copyright notice appear in all copies and that
  99     both that copyright notice and this permission notice appear in
 100     supporting documentation or portions thereof, including modifications,
 101     that you make.
 102
 103     EGENIX.COM SOFTWARE GMBH DISCLAIMS ALL WARRANTIES WITH REGARD TO
 104     THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
 105     FITNESS, IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL,
 106     INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
 107     FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
 108     NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
 109     WITH THE USE OR PERFORMANCE OF THIS SOFTWARE !
 110
 111 """
 112
 113 __version__ = '1.0.6'
 114
 115 import sys,string,os,re
 116
 117 ### Platform specific APIs
 118
 119 _libc_search = re.compile(r'(__libc_init)'
 120                           '|'
 121                           '(GLIBC_([0-9.]+))'
 122                           '|'
 123                           '(libc(_\w+)?\.so(?:\.(\d[0-9.]*))?)')
 124
 125 def libc_ver(executable=sys.executable,lib='',version='',
 126
 127              chunksize=2048):
 128
 129     """ Tries to determine the libc version that the file executable
 130         (which defaults to the Python interpreter) is linked against.
 131
 132         Returns a tuple of strings (lib,version) which default to the
 133         given parameters in case the lookup fails.
 134
 135         Note that the function has intimate knowledge of how different
 136         libc versions add symbols to the executable and thus is probably
 137         only useable for executables compiled using gcc.
 138
 139         The file is read and scanned in chunks of chunksize bytes.
 140
 141     """
 142     if hasattr(os.path, 'realpath'):
 143         # Python 2.2 introduced os.path.realpath(); it is used
 144         # here to work around problems with Cygwin not being
 145         # able to open symlinks for reading
 146         executable = os.path.realpath(executable)
 147     f = open(executable,'rb')
 148     binary = f.read(chunksize)
 149     pos = 0
 150     while 1:
 151         m = _libc_search.search(binary,pos)
 152         if not m:
 153             binary = f.read(chunksize)
 154             if not binary:
 155                 break
 156             pos = 0
 157             continue
 158         libcinit,glibc,glibcversion,so,threads,soversion = m.groups()
 159         if libcinit and not lib:
 160             lib = 'libc'
 161         elif glibc:
 162             if lib != 'glibc':
 163                 lib = 'glibc'
 164                 version = glibcversion
 165             elif glibcversion > version:
 166                 version = glibcversion
 167         elif so:
 168             if lib != 'glibc':
 169                 lib = 'libc'
 170                 if soversion > version:
 171                     version = soversion
 172                 if threads and version[-len(threads):] != threads:
 173                     version = version + threads
 174         pos = m.end()
 175     f.close()
 176     return lib,version
 177
 178 def _dist_try_harder(distname,version,id):
 179
 180     """ Tries some special tricks to get the distribution
 181         information in case the default method fails.
 182
 183         Currently supports older SuSE Linux, Caldera OpenLinux and
 184         Slackware Linux distributions.
 185
 186     """
 187     if os.path.exists('/var/adm/inst-log/info'):
 188         # SuSE Linux stores distribution information in that file
 189         info = open('/var/adm/inst-log/info').readlines()
 190         distname = 'SuSE'
 191         for line in info:
 192             tv = string.split(line)
 193             if len(tv) == 2:
 194                 tag,value = tv
 195             else:
 196                 continue
 197             if tag == 'MIN_DIST_VERSION':
 198                 version = string.strip(value)
 199             elif tag == 'DIST_IDENT':
 200                 values = string.split(value,'-')
 201                 id = values[2]
 202         return distname,version,id
 203
 204     if os.path.exists('/etc/.installed'):
 205         # Caldera OpenLinux has some infos in that file (thanks to Colin Kong)
 206         info = open('/etc/.installed').readlines()
 207         for line in info:
 208             pkg = string.split(line,'-')
 209             if len(pkg) >= 2 and pkg[0] == 'OpenLinux':
 210                 # XXX does Caldera support non Intel platforms ? If yes,
 211                 #     where can we find the needed id ?
 212                 return 'OpenLinux',pkg[1],id
 213
 214     if os.path.isdir('/usr/lib/setup'):
 215         # Check for slackware verson tag file (thanks to Greg Andruk)
 216         verfiles = os.listdir('/usr/lib/setup')
 217         for n in range(len(verfiles)-1, -1, -1):
 218             if verfiles[n][:14] != 'slack-version-':
 219                 del verfiles[n]
 220         if verfiles:
 221             verfiles.sort()
 222             distname = 'slackware'
 223             version = verfiles[-1][14:]
 224             return distname,version,id
 225
 226     return distname,version,id
 227
 228 _release_filename = re.compile(r'(\w+)[-_](release|version)')
 229 _lsb_release_version = re.compile(r'(.+)'
 230                                    ' release '
 231                                    '([\d.]+)'
 232                                    '[^(]*(?:\((.+)\))?')
 233 _release_version = re.compile(r'([^0-9]+)'
 234                                '(?: release )?'
 235                                '([\d.]+)'
 236                                '[^(]*(?:\((.+)\))?')
 237
 238 # See also http://www.novell.com/coolsolutions/feature/11251.html
 239 # and http://linuxmafia.com/faq/Admin/release-files.html
 240 # and http://data.linux-ntfs.org/rpm/whichrpm
 241 # and http://www.die.net/doc/linux/man/man1/lsb_release.1.html
 242
 243 _supported_dists = ('SuSE', 'debian', 'fedora', 'redhat', 'centos',
 244                     'mandrake', 'rocks', 'slackware', 'yellowdog',
 245                     'gentoo', 'UnitedLinux', 'turbolinux')
 246
 247 def _parse_release_file(firstline):
 248
 249     # Parse the first line
 250     m = _lsb_release_version.match(firstline)
 251     if m is not None:
 252         # LSB format: "distro release x.x (codename)"
 253         return tuple(m.groups())
 254
 255     # Pre-LSB format: "distro x.x (codename)"
 256     m = _release_version.match(firstline)
 257     if m is not None:
 258         return tuple(m.groups())
 259
 260     # Unkown format... take the first two words
 261     l = string.split(string.strip(firstline))
 262     if l:
 263         version = l[0]
 264         if len(l) > 1:
 265             id = l[1]
 266         else:
 267             id = ''
 268     return '', version, id
 269
 270 def _test_parse_release_file():
 271
 272     for input, output in (
 273         # Examples of release file contents:
 274         ('SuSE Linux 9.3 (x86-64)', ('SuSE Linux ', '9.3', 'x86-64'))
 275         ('SUSE LINUX 10.1 (X86-64)', ('SUSE LINUX ', '10.1', 'X86-64'))
 276         ('SUSE LINUX 10.1 (i586)', ('SUSE LINUX ', '10.1', 'i586'))
 277         ('Fedora Core release 5 (Bordeaux)', ('Fedora Core', '5', 'Bordeaux'))
 278         ('Red Hat Linux release 8.0 (Psyche)', ('Red Hat Linux', '8.0', 'Psyche'))
 279         ('Red Hat Linux release 9 (Shrike)', ('Red Hat Linux', '9', 'Shrike'))
 280         ('Red Hat Enterprise Linux release 4 (Nahant)', ('Red Hat Enterprise Linux', '4', 'Nahant'))
 281         ('CentOS release 4', ('CentOS', '4', None))
 282         ('Rocks release 4.2.1 (Cydonia)', ('Rocks', '4.2.1', 'Cydonia'))
 283         ):
 284         parsed = _parse_release_file(input)
 285         if parsed != output:
 286             print (input, parsed)
 287
 288 def linux_distribution(distname='', version='', id='',
 289
 290                        supported_dists=_supported_dists,
 291                        full_distribution_name=1):
 292
 293     """ Tries to determine the name of the Linux OS distribution name.
 294
 295         The function first looks for a distribution release file in
 296         /etc and then reverts to _dist_try_harder() in case no
 297         suitable files are found.
 298
 299         supported_dists may be given to define the set of Linux
 300         distributions to look for. It defaults to a list of currently
 301         supported Linux distributions identified by their release file
 302         name.
 303
 304         If full_distribution_name is true (default), the full
 305         distribution read from the OS is returned. Otherwise the short
 306         name taken from supported_dists is used.
 307
 308         Returns a tuple (distname,version,id) which default to the
 309         args given as parameters.
 310
 311     """
 312     try:
 313         etc = os.listdir('/etc')
 314     except os.error:
 315         # Probably not a Unix system
 316         return distname,version,id
 317     etc.sort()
 318     for file in etc:
 319         m = _release_filename.match(file)
 320         if m is not None:
 321             _distname,dummy = m.groups()
 322             if _distname in supported_dists:
 323                 distname = _distname
 324                 break
 325     else:
 326         return _dist_try_harder(distname,version,id)
 327
 328     # Read the first line
 329     f = open('/etc/'+file, 'r')
 330     firstline = f.readline()
 331     f.close()
 332     _distname, _version, _id = _parse_release_file(firstline)
 333
 334     if _distname and full_distribution_name:
 335         distname = _distname
 336     if _version:
 337         version = _version
 338     if _id:
 339         id = _id
 340     return distname, version, id
 341
 342 # To maintain backwards compatibility:
 343
 344 def dist(distname='',version='',id='',
 345
 346          supported_dists=_supported_dists):
 347
 348     """ Tries to determine the name of the Linux OS distribution name.
 349
 350         The function first looks for a distribution release file in
 351         /etc and then reverts to _dist_try_harder() in case no
 352         suitable files are found.
 353
 354         Returns a tuple (distname,version,id) which default to the
 355         args given as parameters.
 356
 357     """
 358     return linux_distribution(distname, version, id,
 359                               supported_dists=supported_dists,
 360                               full_distribution_name=0)
 361
 362 class _popen:
 363
 364     """ Fairly portable (alternative) popen implementation.
 365
 366         This is mostly needed in case os.popen() is not available, or
 367         doesn't work as advertised, e.g. in Win9X GUI programs like
 368         PythonWin or IDLE.
 369
 370         Writing to the pipe is currently not supported.
 371
 372     """
 373     tmpfile = ''
 374     pipe = None
 375     bufsize = None
 376     mode = 'r'
 377
 378     def __init__(self,cmd,mode='r',bufsize=None):
 379
 380         if mode != 'r':
 381             raise ValueError,'popen()-emulation only supports read mode'
 382         import tempfile
 383         self.tmpfile = tmpfile = tempfile.mktemp()
 384         os.system(cmd + ' > %s' % tmpfile)
 385         self.pipe = open(tmpfile,'rb')
 386         self.bufsize = bufsize
 387         self.mode = mode
 388
 389     def read(self):
 390
 391         return self.pipe.read()
 392
 393     def readlines(self):
 394
 395         if self.bufsize is not None:
 396             return self.pipe.readlines()
 397
 398     def close(self,
 399
 400               remove=os.unlink,error=os.error):
 401
 402         if self.pipe:
 403             rc = self.pipe.close()
 404         else:
 405             rc = 255
 406         if self.tmpfile:
 407             try:
 408                 remove(self.tmpfile)
 409             except error:
 410                 pass
 411         return rc
 412
 413     # Alias
 414     __del__ = close
 415
 416 def popen(cmd, mode='r', bufsize=None):
 417
 418     """ Portable popen() interface.
 419     """
 420     # Find a working popen implementation preferring win32pipe.popen
 421     # over os.popen over _popen
 422     popen = None
 423     if os.environ.get('OS','') == 'Windows_NT':
 424         # On NT win32pipe should work; on Win9x it hangs due to bugs
 425         # in the MS C lib (see MS KnowledgeBase article Q150956)
 426         try:
 427             import win32pipe
 428         except ImportError:
 429             pass
 430         else:
 431             popen = win32pipe.popen
 432     if popen is None:
 433         if hasattr(os,'popen'):
 434             popen = os.popen
 435             # Check whether it works... it doesn't in GUI programs
 436             # on Windows platforms
 437             if sys.platform == 'win32': # XXX Others too ?
 438                 try:
 439                     popen('')
 440                 except os.error:
 441                     popen = _popen
 442         else:
 443             popen = _popen
 444     if bufsize is None:
 445         return popen(cmd,mode)
 446     else:
 447         return popen(cmd,mode,bufsize)
 448
 449 def _norm_version(version, build=''):
 450
 451     """ Normalize the version and build strings and return a single
 452         version string using the format major.minor.build (or patchlevel).
 453     """
 454     l = string.split(version,'.')
 455     if build:
 456         l.append(build)
 457     try:
 458         ints = map(int,l)
 459     except ValueError:
 460         strings = l
 461     else:
 462         strings = map(str,ints)
 463     version = string.join(strings[:3],'.')
 464     return version
 465
 466 _ver_output = re.compile(r'(?:([\w ]+) ([\w.]+) '
 467                          '.*'
 468                          'Version ([\d.]+))')
 469
 470 def _syscmd_ver(system='', release='', version='',
 471
 472                supported_platforms=('win32','win16','dos','os2')):
 473
 474     """ Tries to figure out the OS version used and returns
 475         a tuple (system,release,version).
 476
 477         It uses the "ver" shell command for this which is known
 478         to exists on Windows, DOS and OS/2. XXX Others too ?
 479
 480         In case this fails, the given parameters are used as
 481         defaults.
 482
 483     """
 484     if sys.platform not in supported_platforms:
 485         return system,release,version
 486
 487     # Try some common cmd strings
 488     for cmd in ('ver','command /c ver','cmd /c ver'):
 489         try:
 490             pipe = popen(cmd)
 491             info = pipe.read()
 492             if pipe.close():
 493                 raise os.error,'command failed'
 494             # XXX How can I supress shell errors from being written
 495             #     to stderr ?
 496         except os.error,why:
 497             #print 'Command %s failed: %s' % (cmd,why)
 498             continue
 499         except IOError,why:
 500             #print 'Command %s failed: %s' % (cmd,why)
 501             continue
 502         else:
 503             break
 504     else:
 505         return system,release,version
 506
 507     # Parse the output
 508     info = string.strip(info)
 509     m = _ver_output.match(info)
 510     if m is not None:
 511         system,release,version = m.groups()
 512         # Strip trailing dots from version and release
 513         if release[-1] == '.':
 514             release = release[:-1]
 515         if version[-1] == '.':
 516             version = version[:-1]
 517         # Normalize the version and build strings (eliminating additional
 518         # zeros)
 519         version = _norm_version(version)
 520     return system,release,version
 521
 522 def _win32_getvalue(key,name,default=''):
 523
 524     """ Read a value for name from the registry key.
 525
 526         In case this fails, default is returned.
 527
 528     """
 529     from win32api import RegQueryValueEx
 530     try:
 531         return RegQueryValueEx(key,name)
 532     except:
 533         return default
 534
 535 def win32_ver(release='',version='',csd='',ptype=''):
 536
 537     """ Get additional version information from the Windows Registry
 538         and return a tuple (version,csd,ptype) referring to version
 539         number, CSD level and OS type (multi/single
 540         processor).
 541
 542         As a hint: ptype returns 'Uniprocessor Free' on single
 543         processor NT machines and 'Multiprocessor Free' on multi
 544         processor machines. The 'Free' refers to the OS version being
 545         free of debugging code. It could also state 'Checked' which
 546         means the OS version uses debugging code, i.e. code that
 547         checks arguments, ranges, etc. (Thomas Heller).
 548
 549         Note: this function only works if Mark Hammond's win32
 550         package is installed and obviously only runs on Win32
 551         compatible platforms.
 552
 553     """
 554     # XXX Is there any way to find out the processor type on WinXX ?
 555     # XXX Is win32 available on Windows CE ?
 556     #
 557     # Adapted from code posted by Karl Putland to comp.lang.python.
 558     #
 559     # The mappings between reg. values and release names can be found
 560     # here: http://msdn.microsoft.com/library/en-us/sysinfo/base/osversioninfo_str.asp
 561
 562     # Import the needed APIs
 563     try:
 564         import win32api
 565     except ImportError:
 566         return release,version,csd,ptype
 567     from win32api import RegQueryValueEx,RegOpenKeyEx,RegCloseKey,GetVersionEx
 568     from win32con import HKEY_LOCAL_MACHINE,VER_PLATFORM_WIN32_NT,\
 569                          VER_PLATFORM_WIN32_WINDOWS
 570
 571     # Find out the registry key and some general version infos
 572     maj,min,buildno,plat,csd = GetVersionEx()
 573     version = '%i.%i.%i' % (maj,min,buildno & 0xFFFF)
 574     if csd[:13] == 'Service Pack ':
 575         csd = 'SP' + csd[13:]
 576     if plat == VER_PLATFORM_WIN32_WINDOWS:
 577         regkey = 'SOFTWARE\\Microsoft\\Windows\\CurrentVersion'
 578         # Try to guess the release name
 579         if maj == 4:
 580             if min == 0:
 581                 release = '95'
 582             elif min == 10:
 583                 release = '98'
 584             elif min == 90:
 585                 release = 'Me'
 586             else:
 587                 release = 'postMe'
 588         elif maj == 5:
 589             release = '2000'
 590     elif plat == VER_PLATFORM_WIN32_NT:
 591         regkey = 'SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion'
 592         if maj <= 4:
 593             release = 'NT'
 594         elif maj == 5:
 595             if min == 0:
 596                 release = '2000'
 597             elif min == 1:
 598                 release = 'XP'
 599             elif min == 2:
 600                 release = '2003Server'
 601             else:
 602                 release = 'post2003'
 603         elif maj == 6:
 604             if min == 0:
 605                 # Per http://msdn2.microsoft.com/en-us/library/ms724429.aspx
 606                 productType = GetVersionEx(1)[8]
 607                 if productType == 1: # VER_NT_WORKSTATION
 608                     release = 'Vista'
 609                 else:
 610                     release = '2008Server'
 611             else:
 612                 release = 'post2008Server'
 613     else:
 614         if not release:
 615             # E.g. Win3.1 with win32s
 616             release = '%i.%i' % (maj,min)
 617         return release,version,csd,ptype
 618
 619     # Open the registry key
 620     try:
 621         keyCurVer = RegOpenKeyEx(HKEY_LOCAL_MACHINE,regkey)
 622         # Get a value to make sure the key exists...
 623         RegQueryValueEx(keyCurVer,'SystemRoot')
 624     except:
 625         return release,version,csd,ptype
 626
 627     # Parse values
 628     #subversion = _win32_getvalue(keyCurVer,
 629     #                            'SubVersionNumber',
 630     #                            ('',1))[0]
 631     #if subversion:
 632     #   release = release + subversion # 95a, 95b, etc.
 633     build = _win32_getvalue(keyCurVer,
 634                             'CurrentBuildNumber',
 635                             ('',1))[0]
 636     ptype = _win32_getvalue(keyCurVer,
 637                            'CurrentType',
 638                            (ptype,1))[0]
 639
 640     # Normalize version
 641     version = _norm_version(version,build)
 642
 643     # Close key
 644     RegCloseKey(keyCurVer)
 645     return release,version,csd,ptype
 646
 647 def _mac_ver_lookup(selectors,default=None):
 648
 649     from gestalt import gestalt
 650     import MacOS
 651     l = []
 652     append = l.append
 653     for selector in selectors:
 654         try:
 655             append(gestalt(selector))
 656         except (RuntimeError, MacOS.Error):
 657             append(default)
 658     return l
 659
 660 def _bcd2str(bcd):
 661
 662     return hex(bcd)[2:]
 663
 664 def mac_ver(release='',versioninfo=('','',''),machine=''):
 665
 666     """ Get MacOS version information and return it as tuple (release,
 667         versioninfo, machine) with versioninfo being a tuple (version,
 668         dev_stage, non_release_version).
 669
 670         Entries which cannot be determined are set to the paramter values
 671         which default to ''. All tuple entries are strings.
 672
 673         Thanks to Mark R. Levinson for mailing documentation links and
 674         code examples for this function. Documentation for the
 675         gestalt() API is available online at:
 676
 677            http://www.rgaros.nl/gestalt/
 678
 679     """
 680     # Check whether the version info module is available
 681     try:
 682         import gestalt
 683         import MacOS
 684     except ImportError:
 685         return release,versioninfo,machine
 686     # Get the infos
 687     sysv,sysu,sysa = _mac_ver_lookup(('sysv','sysu','sysa'))
 688     # Decode the infos
 689     if sysv:
 690         major = (sysv & 0xFF00) >> 8
 691         minor = (sysv & 0x00F0) >> 4
 692         patch = (sysv & 0x000F)
 693         release = '%s.%i.%i' % (_bcd2str(major),minor,patch)
 694     if sysu:
 695         major =  int((sysu & 0xFF000000L) >> 24)
 696         minor =  (sysu & 0x00F00000) >> 20
 697         bugfix = (sysu & 0x000F0000) >> 16
 698         stage =  (sysu & 0x0000FF00) >> 8
 699         nonrel = (sysu & 0x000000FF)
 700         version = '%s.%i.%i' % (_bcd2str(major),minor,bugfix)
 701         nonrel = _bcd2str(nonrel)
 702         stage = {0x20:'development',
 703                  0x40:'alpha',
 704                  0x60:'beta',
 705                  0x80:'final'}.get(stage,'')
 706         versioninfo = (version,stage,nonrel)
 707     if sysa:
 708         machine = {0x1: '68k',
 709                    0x2: 'PowerPC',
 710                    0xa: 'i386'}.get(sysa,'')
 711     return release,versioninfo,machine
 712
 713 def _java_getprop(name,default):
 714
 715     from java.lang import System
 716     try:
 717         value = System.getProperty(name)
 718         if value is None:
 719             return default
 720         return value
 721     except AttributeError:
 722         return default
 723
 724 def java_ver(release='',vendor='',vminfo=('','',''),osinfo=('','','')):
 725
 726     """ Version interface for Jython.
 727
 728         Returns a tuple (release,vendor,vminfo,osinfo) with vminfo being
 729         a tuple (vm_name,vm_release,vm_vendor) and osinfo being a
 730         tuple (os_name,os_version,os_arch).
 731
 732         Values which cannot be determined are set to the defaults
 733         given as parameters (which all default to '').
 734
 735     """
 736     # Import the needed APIs
 737     try:
 738         import java.lang
 739     except ImportError:
 740         return release,vendor,vminfo,osinfo
 741
 742     vendor = _java_getprop('java.vendor', vendor)
 743     release = _java_getprop('java.version', release)
 744     vm_name, vm_release, vm_vendor = vminfo
 745     vm_name = _java_getprop('java.vm.name', vm_name)
 746     vm_vendor = _java_getprop('java.vm.vendor', vm_vendor)
 747     vm_release = _java_getprop('java.vm.version', vm_release)
 748     vminfo = vm_name, vm_release, vm_vendor
 749     os_name, os_version, os_arch = osinfo
 750     os_arch = _java_getprop('java.os.arch', os_arch)
 751     os_name = _java_getprop('java.os.name', os_name)
 752     os_version = _java_getprop('java.os.version', os_version)
 753     osinfo = os_name, os_version, os_arch
 754
 755     return release, vendor, vminfo, osinfo
 756
 757 ### System name aliasing
 758
 759 def system_alias(system,release,version):
 760
 761     """ Returns (system,release,version) aliased to common
 762         marketing names used for some systems.
 763
 764         It also does some reordering of the information in some cases
 765         where it would otherwise cause confusion.
 766
 767     """
 768     if system == 'Rhapsody':
 769         # Apple's BSD derivative
 770         # XXX How can we determine the marketing release number ?
 771         return 'MacOS X Server',system+release,version
 772
 773     elif system == 'SunOS':
 774         # Sun's OS
 775         if release < '5':
 776             # These releases use the old name SunOS
 777             return system,release,version
 778         # Modify release (marketing release = SunOS release - 3)
 779         l = string.split(release,'.')
 780         if l:
 781             try:
 782                 major = int(l[0])
 783             except ValueError:
 784                 pass
 785             else:
 786                 major = major - 3
 787                 l[0] = str(major)
 788                 release = string.join(l,'.')
 789         if release < '6':
 790             system = 'Solaris'
 791         else:
 792             # XXX Whatever the new SunOS marketing name is...
 793             system = 'Solaris'
 794
 795     elif system == 'IRIX64':
 796         # IRIX reports IRIX64 on platforms with 64-bit support; yet it
 797         # is really a version and not a different platform, since 32-bit
 798         # apps are also supported..
 799         system = 'IRIX'
 800         if version:
 801             version = version + ' (64bit)'
 802         else:
 803             version = '64bit'
 804
 805     elif system in ('win32','win16'):
 806         # In case one of the other tricks
 807         system = 'Windows'
 808
 809     return system,release,version
 810
 811 ### Various internal helpers
 812
 813 def _platform(*args):
 814
 815     """ Helper to format the platform string in a filename
 816         compatible format e.g. "system-version-machine".
 817     """
 818     # Format the platform string
 819     platform = string.join(
 820         map(string.strip,
 821             filter(len, args)),
 822         '-')
 823
 824     # Cleanup some possible filename obstacles...
 825     replace = string.replace
 826     platform = replace(platform,' ','_')
 827     platform = replace(platform,'/','-')
 828     platform = replace(platform,'\\','-')
 829     platform = replace(platform,':','-')
 830     platform = replace(platform,';','-')
 831     platform = replace(platform,'"','-')
 832     platform = replace(platform,'(','-')
 833     platform = replace(platform,')','-')
 834
 835     # No need to report 'unknown' information...
 836     platform = replace(platform,'unknown','')
 837
 838     # Fold '--'s and remove trailing '-'
 839     while 1:
 840         cleaned = replace(platform,'--','-')
 841         if cleaned == platform:
 842             break
 843         platform = cleaned
 844     while platform[-1] == '-':
 845         platform = platform[:-1]
 846
 847     return platform
 848
 849 def _node(default=''):
 850
 851     """ Helper to determine the node name of this machine.
 852     """
 853     try:
 854         import socket
 855     except ImportError:
 856         # No sockets...
 857         return default
 858     try:
 859         return socket.gethostname()
 860     except socket.error:
 861         # Still not working...
 862         return default
 863
 864 # os.path.abspath is new in Python 1.5.2:
 865 if not hasattr(os.path,'abspath'):
 866
 867     def _abspath(path,
 868
 869                  isabs=os.path.isabs,join=os.path.join,getcwd=os.getcwd,
 870                  normpath=os.path.normpath):
 871
 872         if not isabs(path):
 873             path = join(getcwd(), path)
 874         return normpath(path)
 875
 876 else:
 877
 878     _abspath = os.path.abspath
 879
 880 def _follow_symlinks(filepath):
 881
 882     """ In case filepath is a symlink, follow it until a
 883         real file is reached.
 884     """
 885     filepath = _abspath(filepath)
 886     while os.path.islink(filepath):
 887         filepath = os.path.normpath(
 888             os.path.join(filepath,os.readlink(filepath)))
 889     return filepath
 890
 891 def _syscmd_uname(option,default=''):
 892
 893     """ Interface to the system's uname command.
 894     """
 895     if sys.platform in ('dos','win32','win16','os2'):
 896         # XXX Others too ?
 897         return default
 898     try:
 899         f = os.popen('uname %s 2> /dev/null' % option)
 900     except (AttributeError,os.error):
 901         return default
 902     output = string.strip(f.read())
 903     rc = f.close()
 904     if not output or rc:
 905         return default
 906     else:
 907         return output
 908
 909 def _syscmd_file(target,default=''):
 910
 911     """ Interface to the system's file command.
 912
 913         The function uses the -b option of the file command to have it
 914         ommit the filename in its output and if possible the -L option
 915         to have the command follow symlinks. It returns default in
 916         case the command should fail.
 917
 918     """
 919     target = _follow_symlinks(target)
 920     try:
 921         f = os.popen('file %s 2> /dev/null' % target)
 922     except (AttributeError,os.error):
 923         return default
 924     output = string.strip(f.read())
 925     rc = f.close()
 926     if not output or rc:
 927         return default
 928     else:
 929         return output
 930
 931 ### Information about the used architecture
 932
 933 # Default values for architecture; non-empty strings override the
 934 # defaults given as parameters
 935 _default_architecture = {
 936     'win32': ('','WindowsPE'),
 937     'win16': ('','Windows'),
 938     'dos': ('','MSDOS'),
 939 }
 940
 941 _architecture_split = re.compile(r'[\s,]').split
 942
 943 def architecture(executable=sys.executable,bits='',linkage=''):
 944
 945     """ Queries the given executable (defaults to the Python interpreter
 946         binary) for various architecture information.
 947
 948         Returns a tuple (bits,linkage) which contains information about
 949         the bit architecture and the linkage format used for the
 950         executable. Both values are returned as strings.
 951
 952         Values that cannot be determined are returned as given by the
 953         parameter presets. If bits is given as '', the sizeof(pointer)
 954         (or sizeof(long) on Python version < 1.5.2) is used as
 955         indicator for the supported pointer size.
 956
 957         The function relies on the system's "file" command to do the
 958         actual work. This is available on most if not all Unix
 959         platforms. On some non-Unix platforms where the "file" command
 960         does not exist and the executable is set to the Python interpreter
 961         binary defaults from _default_architecture are used.
 962
 963     """
 964     # Use the sizeof(pointer) as default number of bits if nothing
 965     # else is given as default.
 966     if not bits:
 967         import struct
 968         try:
 969             size = struct.calcsize('P')
 970         except struct.error:
 971             # Older installations can only query longs
 972             size = struct.calcsize('l')
 973         bits = str(size*8) + 'bit'
 974
 975     # Get data from the 'file' system command
 976     if executable:
 977         output = _syscmd_file(executable, '')
 978     else:
 979         output = ''
 980
 981     if not output and \
 982        executable == sys.executable:
 983         # "file" command did not return anything; we'll try to provide
 984         # some sensible defaults then...
 985         if _default_architecture.has_key(sys.platform):
 986             b,l = _default_architecture[sys.platform]
 987             if b:
 988                 bits = b
 989             if l:
 990                 linkage = l
 991         return bits,linkage
 992
 993     # Split the output into a list of strings omitting the filename
 994     fileout = _architecture_split(output)[1:]
 995
 996     if 'executable' not in fileout:
 997         # Format not supported
 998         return bits,linkage
 999
1000     # Bits
1001     if '32-bit' in fileout:
1002         bits = '32bit'
1003     elif 'N32' in fileout:
1004         # On Irix only
1005         bits = 'n32bit'
1006     elif '64-bit' in fileout:
1007         bits = '64bit'
1008
1009     # Linkage
1010     if 'ELF' in fileout:
1011         linkage = 'ELF'
1012     elif 'PE' in fileout:
1013         # E.g. Windows uses this format
1014         if 'Windows' in fileout:
1015             linkage = 'WindowsPE'
1016         else:
1017             linkage = 'PE'
1018     elif 'COFF' in fileout:
1019         linkage = 'COFF'
1020     elif 'MS-DOS' in fileout:
1021         linkage = 'MSDOS'
1022     else:
1023         # XXX the A.OUT format also falls under this class...
1024         pass
1025
1026     return bits,linkage
1027
1028 ### Portable uname() interface
1029
1030 _uname_cache = None
1031
1032 def uname():
1033
1034     """ Fairly portable uname interface. Returns a tuple
1035         of strings (system,node,release,version,machine,processor)
1036         identifying the underlying platform.
1037
1038         Note that unlike the os.uname function this also returns
1039         possible processor information as an additional tuple entry.
1040
1041         Entries which cannot be determined are set to ''.
1042
1043     """
1044     global _uname_cache
1045
1046     if _uname_cache is not None:
1047         return _uname_cache
1048
1049     # Get some infos from the builtin os.uname API...
1050     try:
1051         system,node,release,version,machine = os.uname()
1052
1053     except AttributeError:
1054         # Hmm, no uname... we'll have to poke around the system then.
1055         system = sys.platform
1056         release = ''
1057         version = ''
1058         node = _node()
1059         machine = ''
1060         processor = ''
1061         use_syscmd_ver = 1
1062
1063         # Try win32_ver() on win32 platforms
1064         if system == 'win32':
1065             release,version,csd,ptype = win32_ver()
1066             if release and version:
1067                 use_syscmd_ver = 0
1068             # XXX Should try to parse the PROCESSOR_* environment variables
1069             # available on Win XP and later; see
1070             # http://support.microsoft.com/kb/888731 and
1071             # http://www.geocities.com/rick_lively/MANUALS/ENV/MSWIN/PROCESSI.HTM
1072
1073         # Try the 'ver' system command available on some
1074         # platforms
1075         if use_syscmd_ver:
1076             system,release,version = _syscmd_ver(system)
1077             # Normalize system to what win32_ver() normally returns
1078             # (_syscmd_ver() tends to return the vendor name as well)
1079             if system == 'Microsoft Windows':
1080                 system = 'Windows'
1081             elif system == 'Microsoft' and release == 'Windows':
1082                 # Under Windows Vista and Windows Server 2008,
1083                 # Microsoft changed the output of the ver command. The
1084                 # release is no longer printed.  This causes the
1085                 # system and release to be misidentified.
1086                 system = 'Windows'
1087                 if '6.0' == version[:3]:
1088                     release = 'Vista'
1089                 else:
1090                     release = ''
1091
1092         # In case we still don't know anything useful, we'll try to
1093         # help ourselves
1094         if system in ('win32','win16'):
1095             if not version:
1096                 if system == 'win32':
1097                     version = '32bit'
1098                 else:
1099                     version = '16bit'
1100             system = 'Windows'
1101
1102         elif system[:4] == 'java':
1103             release,vendor,vminfo,osinfo = java_ver()
1104             system = 'Java'
1105             version = string.join(vminfo,', ')
1106             if not version:
1107                 version = vendor
1108
1109         elif os.name == 'mac':
1110             release,(version,stage,nonrel),machine = mac_ver()
1111             system = 'MacOS'
1112
1113     else:
1114         # System specific extensions
1115         if system == 'OpenVMS':
1116             # OpenVMS seems to have release and version mixed up
1117             if not release or release == '0':
1118                 release = version
1119                 version = ''
1120             # Get processor information
1121             try:
1122                 import vms_lib
1123             except ImportError:
1124                 pass
1125             else:
1126                 csid, cpu_number = vms_lib.getsyi('SYI$_CPU',0)
1127                 if (cpu_number >= 128):
1128                     processor = 'Alpha'
1129                 else:
1130                     processor = 'VAX'
1131         else:
1132             # Get processor information from the uname system command
1133             processor = _syscmd_uname('-p','')
1134
1135     # 'unknown' is not really any useful as information; we'll convert
1136     # it to '' which is more portable
1137     if system == 'unknown':
1138         system = ''
1139     if node == 'unknown':
1140         node = ''
1141     if release == 'unknown':
1142         release = ''
1143     if version == 'unknown':
1144         version = ''
1145     if machine == 'unknown':
1146         machine = ''
1147     if processor == 'unknown':
1148         processor = ''
1149
1150     #  normalize name
1151     if system == 'Microsoft' and release == 'Windows':
1152         system = 'Windows'
1153         release = 'Vista'
1154
1155     _uname_cache = system,node,release,version,machine,processor
1156     return _uname_cache
1157
1158 ### Direct interfaces to some of the uname() return values
1159
1160 def system():
1161
1162     """ Returns the system/OS name, e.g. 'Linux', 'Windows' or 'Java'.
1163
1164         An empty string is returned if the value cannot be determined.
1165
1166     """
1167     return uname()[0]
1168
1169 def node():
1170
1171     """ Returns the computer's network name (which may not be fully
1172         qualified)
1173
1174         An empty string is returned if the value cannot be determined.
1175
1176     """
1177     return uname()[1]
1178
1179 def release():
1180
1181     """ Returns the system's release, e.g. '2.2.0' or 'NT'
1182
1183         An empty string is returned if the value cannot be determined.
1184
1185     """
1186     return uname()[2]
1187
1188 def version():
1189
1190     """ Returns the system's release version, e.g. '#3 on degas'
1191
1192         An empty string is returned if the value cannot be determined.
1193
1194     """
1195     return uname()[3]
1196
1197 def machine():
1198
1199     """ Returns the machine type, e.g. 'i386'
1200
1201         An empty string is returned if the value cannot be determined.
1202
1203     """
1204     return uname()[4]
1205
1206 def processor():
1207
1208     """ Returns the (true) processor name, e.g. 'amdk6'
1209
1210         An empty string is returned if the value cannot be
1211         determined. Note that many platforms do not provide this
1212         information or simply return the same value as for machine(),
1213         e.g.  NetBSD does this.
1214
1215     """
1216     return uname()[5]
1217
1218 ### Various APIs for extracting information from sys.version
1219
1220 _sys_version_parser = re.compile(
1221     r'([\w.+]+)\s*'
1222     '\(#?([^,]+),\s*([\w ]+),\s*([\w :]+)\)\s*'
1223     '\[([^\]]+)\]?')
1224
1225 _jython_sys_version_parser = re.compile(
1226     r'([\d\.]+)')
1227
1228 _ironpython_sys_version_parser = re.compile(
1229     r'IronPython\s*'
1230     '([\d\.]+)'
1231     '(?: \(([\d\.]+)\))?'
1232     ' on (.NET [\d\.]+)')
1233
1234 _sys_version_cache = {}
1235
1236 def _sys_version(sys_version=None):
1237
1238     """ Returns a parsed version of Python's sys.version as tuple
1239        (name, version, branch, revision, buildno, builddate, compiler)
1240        referring to the Python implementation name, version, branch,
1241        revision, build number, build date/time as string and the compiler
1242        identification string.
1243
1244         Note that unlike the Python sys.version, the returned value
1245         for the Python version will always include the patchlevel (it
1246         defaults to '.0').
1247
1248         The function returns empty strings for tuple entries that
1249         cannot be determined.
1250
1251         sys_version may be given to parse an alternative version
1252         string, e.g. if the version was read from a different Python
1253         interpreter.
1254
1255     """
1256     # Get the Python version
1257     if sys_version is None:
1258         sys_version = sys.version
1259
1260     # Try the cache first
1261     result = _sys_version_cache.get(sys_version, None)
1262     if result is not None:
1263         return result
1264
1265     # Parse it
1266     if sys_version[:10] == 'IronPython':
1267         # IronPython
1268         name = 'IronPython'
1269         match = _ironpython_sys_version_parser.match(sys_version)
1270         if match is None:
1271             raise ValueError(
1272                 'failed to parse IronPython sys.version: %s' %
1273                 repr(sys_version))
1274         version, alt_version, compiler = match.groups()
1275         branch = ''
1276         revision = ''
1277         buildno = ''
1278         builddate = ''
1279
1280     elif sys.platform[:4] == 'java':
1281         # Jython
1282         name = 'Jython'
1283         match = _jython_sys_version_parser.match(sys_version)
1284         if match is None:
1285             raise ValueError(
1286                 'failed to parse Jython sys.version: %s' %
1287                 repr(sys_version))
1288         version, = match.groups()
1289         branch = ''
1290         revision = ''
1291         compiler = sys.platform
1292         buildno = ''
1293         builddate = ''
1294
1295     else:
1296         # CPython
1297         match = _sys_version_parser.match(sys_version)
1298         if match is None:
1299             raise ValueError(
1300                 'failed to parse CPython sys.version: %s' %
1301                 repr(sys_version))
1302         version, buildno, builddate, buildtime, compiler = \
1303               match.groups()
1304         if hasattr(sys, 'subversion'):
1305             # sys.subversion was added in Python 2.5
1306             name, branch, revision = sys.subversion
1307         else:
1308             name = 'CPython'
1309             branch = ''
1310             revision = ''
1311         builddate = builddate + ' ' + buildtime
1312
1313     # Add the patchlevel version if missing
1314     l = string.split(version, '.')
1315     if len(l) == 2:
1316         l.append('0')
1317         version = string.join(l, '.')
1318
1319     # Build and cache the result
1320     result = (name, version, branch, revision, buildno, builddate, compiler)
1321     _sys_version_cache[sys_version] = result
1322     return result
1323
1324 def _test_sys_version():
1325
1326     _sys_version_cache.clear()
1327     for input, output in (
1328         ('2.4.3 (#1, Jun 21 2006, 13:54:21) \n[GCC 3.3.4 (pre 3.3.5 20040809)]',
1329          ('CPython', '2.4.3', '', '', '1', 'Jun 21 2006 13:54:21', 'GCC 3.3.4 (pre 3.3.5 20040809)')),
1330         ('IronPython 1.0.60816 on .NET 2.0.50727.42',
1331          ('IronPython', '1.0.60816', '', '', '', '', '.NET 2.0.50727.42')),
1332         ('IronPython 1.0 (1.0.61005.1977) on .NET 2.0.50727.42',
1333          ('IronPython', '1.0.0', '', '', '', '', '.NET 2.0.50727.42')),
1334         ):
1335         parsed = _sys_version(input)
1336         if parsed != output:
1337             print (input, parsed)
1338
1339 def python_implementation():
1340
1341     """ Returns a string identifying the Python implementation.
1342
1343         Currently, the following implementations are identified:
1344         'CPython' (C implementation of Python),
1345         'IronPython' (.NET implementation of Python),
1346         'Jython' (Java implementation of Python).
1347
1348     """
1349     return _sys_version()[0]
1350
1351 def python_version():
1352
1353     """ Returns the Python version as string 'major.minor.patchlevel'
1354
1355         Note that unlike the Python sys.version, the returned value
1356         will always include the patchlevel (it defaults to 0).
1357
1358     """
1359     if hasattr(sys, 'version_info'):
1360         return '%i.%i.%i' % sys.version_info[:3]
1361     return _sys_version()[1]
1362
1363 def python_version_tuple():
1364
1365     """ Returns the Python version as tuple (major, minor, patchlevel)
1366         of strings.
1367
1368         Note that unlike the Python sys.version, the returned value
1369         will always include the patchlevel (it defaults to 0).
1370
1371     """
1372     if hasattr(sys, 'version_info'):
1373         return sys.version_info[:3]
1374     return tuple(string.split(_sys_version()[1], '.'))
1375
1376 def python_branch():
1377
1378     """ Returns a string identifying the Python implementation
1379         branch.
1380
1381         For CPython this is the Subversion branch from which the
1382         Python binary was built.
1383
1384         If not available, an empty string is returned.
1385
1386     """
1387
1388     return _sys_version()[2]
1389
1390 def python_revision():
1391
1392     """ Returns a string identifying the Python implementation
1393         revision.
1394
1395         For CPython this is the Subversion revision from which the
1396         Python binary was built.
1397
1398         If not available, an empty string is returned.
1399
1400     """
1401     return _sys_version()[3]
1402
1403 def python_build():
1404
1405     """ Returns a tuple (buildno, builddate) stating the Python
1406         build number and date as strings.
1407
1408     """
1409     return _sys_version()[4:6]
1410
1411 def python_compiler():
1412
1413     """ Returns a string identifying the compiler used for compiling
1414         Python.
1415
1416     """
1417     return _sys_version()[6]
1418
1419 ### The Opus Magnum of platform strings :-)
1420
1421 _platform_cache = {}
1422
1423 def platform(aliased=0, terse=0):
1424
1425     """ Returns a single string identifying the underlying platform
1426         with as much useful information as possible (but no more :).
1427
1428         The output is intended to be human readable rather than
1429         machine parseable. It may look different on different
1430         platforms and this is intended.
1431
1432         If "aliased" is true, the function will use aliases for
1433         various platforms that report system names which differ from
1434         their common names, e.g. SunOS will be reported as
1435         Solaris. The system_alias() function is used to implement
1436         this.
1437
1438         Setting terse to true causes the function to return only the
1439         absolute minimum information needed to identify the platform.
1440
1441     """
1442     result = _platform_cache.get((aliased, terse), None)
1443     if result is not None:
1444         return result
1445
1446     # Get uname information and then apply platform specific cosmetics
1447     # to it...
1448     system,node,release,version,machine,processor = uname()
1449     if machine == processor:
1450         processor = ''
1451     if aliased:
1452         system,release,version = system_alias(system,release,version)
1453
1454     if system == 'Windows':
1455         # MS platforms
1456         rel,vers,csd,ptype = win32_ver(version)
1457         if terse:
1458             platform = _platform(system,release)
1459         else:
1460             platform = _platform(system,release,version,csd)
1461
1462     elif system in ('Linux',):
1463         # Linux based systems
1464         distname,distversion,distid = dist('')
1465         if distname and not terse:
1466             platform = _platform(system,release,machine,processor,
1467                                  'with',
1468                                  distname,distversion,distid)
1469         else:
1470             # If the distribution name is unknown check for libc vs. glibc
1471             libcname,libcversion = libc_ver(sys.executable)
1472             platform = _platform(system,release,machine,processor,
1473                                  'with',
1474                                  libcname+libcversion)
1475     elif system == 'Java':
1476         # Java platforms
1477         r,v,vminfo,(os_name,os_version,os_arch) = java_ver()
1478         if terse or not os_name:
1479             platform = _platform(system,release,version)
1480         else:
1481             platform = _platform(system,release,version,
1482                                  'on',
1483                                  os_name,os_version,os_arch)
1484
1485     elif system == 'MacOS':
1486         # MacOS platforms
1487         if terse:
1488             platform = _platform(system,release)
1489         else:
1490             platform = _platform(system,release,machine)
1491
1492     else:
1493         # Generic handler
1494         if terse:
1495             platform = _platform(system,release)
1496         else:
1497             bits,linkage = architecture(sys.executable)
1498             platform = _platform(system,release,machine,processor,bits,linkage)
1499
1500     _platform_cache[(aliased, terse)] = platform
1501     return platform
1502
1503 ### Command line interface
1504
1505 if __name__ == '__main__':
1506     # Default is to print the aliased verbose platform string
1507     terse = ('terse' in sys.argv or '--terse' in sys.argv)
1508     aliased = (not 'nonaliased' in sys.argv and not '--nonaliased' in sys.argv)
1509     print platform(aliased,terse)
1510     sys.exit(0)