home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2004 #2 / K-CD-2-2004.ISO / OpenOffice Sv / f_0397 / python-core-2.2.2 / lib / distutils / util.py < prev    next >
Encoding:
Python Source  |  2003-07-18  |  16.8 KB  |  458 lines
  1. """distutils.util
  2.  
  3. Miscellaneous utility functions -- anything that doesn't fit into
  4. one of the other *util.py modules.
  5. """
  6.  
  7. # created 1999/03/08, Greg Ward
  8.  
  9. __revision__ = "$Id: util.py,v 1.65.6.1 2002/08/13 17:49:18 nnorwitz Exp $"
  10.  
  11. import sys, os, string, re
  12. from distutils.errors import DistutilsPlatformError
  13. from distutils.dep_util import newer
  14. from distutils.spawn import spawn
  15.  
  16.  
  17. def get_platform ():
  18.     """Return a string that identifies the current platform.  This is used
  19.     mainly to distinguish platform-specific build directories and
  20.     platform-specific built distributions.  Typically includes the OS name
  21.     and version and the architecture (as supplied by 'os.uname()'),
  22.     although the exact information included depends on the OS; eg. for IRIX
  23.     the architecture isn't particularly important (IRIX only runs on SGI
  24.     hardware), but for Linux the kernel version isn't particularly
  25.     important.
  26.  
  27.     Examples of returned values:
  28.        linux-i586
  29.        linux-alpha (?)
  30.        solaris-2.6-sun4u
  31.        irix-5.3
  32.        irix64-6.2
  33.  
  34.     For non-POSIX platforms, currently just returns 'sys.platform'.
  35.     """
  36.     if os.name != "posix" or not hasattr(os, 'uname'):
  37.         # XXX what about the architecture? NT is Intel or Alpha,
  38.         # Mac OS is M68k or PPC, etc.
  39.         return sys.platform
  40.  
  41.     # Try to distinguish various flavours of Unix
  42.  
  43.     (osname, host, release, version, machine) = os.uname()
  44.  
  45.     # Convert the OS name to lowercase and remove '/' characters
  46.     # (to accommodate BSD/OS)
  47.     osname = string.lower(osname)
  48.     osname = string.replace(osname, '/', '')
  49.  
  50.     if osname[:5] == "linux":
  51.         # At least on Linux/Intel, 'machine' is the processor --
  52.         # i386, etc.
  53.         # XXX what about Alpha, SPARC, etc?
  54.         return  "%s-%s" % (osname, machine)
  55.     elif osname[:5] == "sunos":
  56.         if release[0] >= "5":           # SunOS 5 == Solaris 2
  57.             osname = "solaris"
  58.             release = "%d.%s" % (int(release[0]) - 3, release[2:])
  59.         # fall through to standard osname-release-machine representation
  60.     elif osname[:4] == "irix":              # could be "irix64"!
  61.         return "%s-%s" % (osname, release)
  62.     elif osname[:3] == "aix":
  63.         return "%s-%s.%s" % (osname, version, release)
  64.     elif osname[:6] == "cygwin":
  65.         osname = "cygwin"
  66.         rel_re = re.compile (r'[\d.]+')
  67.         m = rel_re.match(release)
  68.         if m:
  69.             release = m.group()
  70.  
  71.     return "%s-%s-%s" % (osname, release, machine)
  72.  
  73. # get_platform ()
  74.  
  75.  
  76. def convert_path (pathname):
  77.     """Return 'pathname' as a name that will work on the native filesystem,
  78.     i.e. split it on '/' and put it back together again using the current
  79.     directory separator.  Needed because filenames in the setup script are
  80.     always supplied in Unix style, and have to be converted to the local
  81.     convention before we can actually use them in the filesystem.  Raises
  82.     ValueError on non-Unix-ish systems if 'pathname' either starts or
  83.     ends with a slash.
  84.     """
  85.     if os.sep == '/':
  86.         return pathname
  87.     if not pathname:
  88.         return pathname
  89.     if pathname[0] == '/':
  90.         raise ValueError, "path '%s' cannot be absolute" % pathname
  91.     if pathname[-1] == '/':
  92.         raise ValueError, "path '%s' cannot end with '/'" % pathname
  93.  
  94.     paths = string.split(pathname, '/')
  95.     while '.' in paths:
  96.         paths.remove('.')
  97.     if not paths:
  98.         return os.curdir
  99.     return apply(os.path.join, paths)
  100.  
  101. # convert_path ()
  102.  
  103.  
  104. def change_root (new_root, pathname):
  105.     """Return 'pathname' with 'new_root' prepended.  If 'pathname' is
  106.     relative, this is equivalent to "os.path.join(new_root,pathname)".
  107.     Otherwise, it requires making 'pathname' relative and then joining the
  108.     two, which is tricky on DOS/Windows and Mac OS.
  109.     """
  110.     if os.name == 'posix':
  111.         if not os.path.isabs(pathname):
  112.             return os.path.join(new_root, pathname)
  113.         else:
  114.             return os.path.join(new_root, pathname[1:])
  115.  
  116.     elif os.name == 'nt':
  117.         (drive, path) = os.path.splitdrive(pathname)
  118.         if path[0] == '\\':
  119.             path = path[1:]
  120.         return os.path.join(new_root, path)
  121.  
  122.     elif os.name == 'mac':
  123.         if not os.path.isabs(pathname):
  124.             return os.path.join(new_root, pathname)
  125.         else:
  126.             # Chop off volume name from start of path
  127.             elements = string.split(pathname, ":", 1)
  128.             pathname = ":" + elements[1]
  129.             return os.path.join(new_root, pathname)
  130.  
  131.     else:
  132.         raise DistutilsPlatformError, \
  133.               "nothing known about platform '%s'" % os.name
  134.  
  135.  
  136. _environ_checked = 0
  137. def check_environ ():
  138.     """Ensure that 'os.environ' has all the environment variables we
  139.     guarantee that users can use in config files, command-line options,
  140.     etc.  Currently this includes:
  141.       HOME - user's home directory (Unix only)
  142.       PLAT - description of the current platform, including hardware
  143.              and OS (see 'get_platform()')
  144.     """
  145.     global _environ_checked
  146.     if _environ_checked:
  147.         return
  148.  
  149.     if os.name == 'posix' and not os.environ.has_key('HOME'):
  150.         import pwd
  151.         os.environ['HOME'] = pwd.getpwuid(os.getuid())[5]
  152.  
  153.     if not os.environ.has_key('PLAT'):
  154.         os.environ['PLAT'] = get_platform()
  155.  
  156.     _environ_checked = 1
  157.  
  158.  
  159. def subst_vars (s, local_vars):
  160.     """Perform shell/Perl-style variable substitution on 'string'.  Every
  161.     occurrence of '$' followed by a name is considered a variable, and
  162.     variable is substituted by the value found in the 'local_vars'
  163.     dictionary, or in 'os.environ' if it's not in 'local_vars'.
  164.     'os.environ' is first checked/augmented to guarantee that it contains
  165.     certain values: see 'check_environ()'.  Raise ValueError for any
  166.     variables not found in either 'local_vars' or 'os.environ'.
  167.     """
  168.     check_environ()
  169.     def _subst (match, local_vars=local_vars):
  170.         var_name = match.group(1)
  171.         if local_vars.has_key(var_name):
  172.             return str(local_vars[var_name])
  173.         else:
  174.             return os.environ[var_name]
  175.  
  176.     try:
  177.         return re.sub(r'\$([a-zA-Z_][a-zA-Z_0-9]*)', _subst, s)
  178.     except KeyError, var:
  179.         raise ValueError, "invalid variable '$%s'" % var
  180.  
  181. # subst_vars ()
  182.  
  183.  
  184. def grok_environment_error (exc, prefix="error: "):
  185.     """Generate a useful error message from an EnvironmentError (IOError or
  186.     OSError) exception object.  Handles Python 1.5.1 and 1.5.2 styles, and
  187.     does what it can to deal with exception objects that don't have a
  188.     filename (which happens when the error is due to a two-file operation,
  189.     such as 'rename()' or 'link()'.  Returns the error message as a string
  190.     prefixed with 'prefix'.
  191.     """
  192.     # check for Python 1.5.2-style {IO,OS}Error exception objects
  193.     if hasattr(exc, 'filename') and hasattr(exc, 'strerror'):
  194.         if exc.filename:
  195.             error = prefix + "%s: %s" % (exc.filename, exc.strerror)
  196.         else:
  197.             # two-argument functions in posix module don't
  198.             # include the filename in the exception object!
  199.             error = prefix + "%s" % exc.strerror
  200.     else:
  201.         error = prefix + str(exc[-1])
  202.  
  203.     return error
  204.  
  205.  
  206. # Needed by 'split_quoted()'
  207. _wordchars_re = re.compile(r'[^\\\'\"%s ]*' % string.whitespace)
  208. _squote_re = re.compile(r"'(?:[^'\\]|\\.)*'")
  209. _dquote_re = re.compile(r'"(?:[^"\\]|\\.)*"')
  210.  
  211. def split_quoted (s):
  212.     """Split a string up according to Unix shell-like rules for quotes and
  213.     backslashes.  In short: words are delimited by spaces, as long as those
  214.     spaces are not escaped by a backslash, or inside a quoted string.
  215.     Single and double quotes are equivalent, and the quote characters can
  216.     be backslash-escaped.  The backslash is stripped from any two-character
  217.     escape sequence, leaving only the escaped character.  The quote
  218.     characters are stripped from any quoted string.  Returns a list of
  219.     words.
  220.     """
  221.  
  222.     # This is a nice algorithm for splitting up a single string, since it
  223.     # doesn't require character-by-character examination.  It was a little
  224.     # bit of a brain-bender to get it working right, though...
  225.  
  226.     s = string.strip(s)
  227.     words = []
  228.     pos = 0
  229.  
  230.     while s:
  231.         m = _wordchars_re.match(s, pos)
  232.         end = m.end()
  233.         if end == len(s):
  234.             words.append(s[:end])
  235.             break
  236.  
  237.         if s[end] in string.whitespace: # unescaped, unquoted whitespace: now
  238.             words.append(s[:end])       # we definitely have a word delimiter
  239.             s = string.lstrip(s[end:])
  240.             pos = 0
  241.  
  242.         elif s[end] == '\\':            # preserve whatever is being escaped;
  243.                                         # will become part of the current word
  244.             s = s[:end] + s[end+1:]
  245.             pos = end+1
  246.  
  247.         else:
  248.             if s[end] == "'":           # slurp singly-quoted string
  249.                 m = _squote_re.match(s, end)
  250.             elif s[end] == '"':         # slurp doubly-quoted string
  251.                 m = _dquote_re.match(s, end)
  252.             else:
  253.                 raise RuntimeError, \
  254.                       "this can't happen (bad char '%c')" % s[end]
  255.  
  256.             if m is None:
  257.                 raise ValueError, \
  258.                       "bad string (mismatched %s quotes?)" % s[end]
  259.  
  260.             (beg, end) = m.span()
  261.             s = s[:beg] + s[beg+1:end-1] + s[end:]
  262.             pos = m.end() - 2
  263.  
  264.         if pos >= len(s):
  265.             words.append(s)
  266.             break
  267.  
  268.     return words
  269.  
  270. # split_quoted ()
  271.  
  272.  
  273. def execute (func, args, msg=None, verbose=0, dry_run=0):
  274.     """Perform some action that affects the outside world (eg.  by writing
  275.     to the filesystem).  Such actions are special because they are disabled
  276.     by the 'dry_run' flag, and announce themselves if 'verbose' is true.
  277.     This method takes care of all that bureaucracy for you; all you have to
  278.     do is supply the function to call and an argument tuple for it (to
  279.     embody the "external action" being performed), and an optional message
  280.     to print.
  281.     """
  282.     # Generate a message if we weren't passed one
  283.     if msg is None:
  284.         msg = "%s%s" % (func.__name__, `args`)
  285.         if msg[-2:] == ',)':        # correct for singleton tuple
  286.             msg = msg[0:-2] + ')'
  287.  
  288.     # Print it if verbosity level is high enough
  289.     if verbose:
  290.         print msg
  291.  
  292.     # And do it, as long as we're not in dry-run mode
  293.     if not dry_run:
  294.         apply(func, args)
  295.  
  296. # execute()
  297.  
  298.  
  299. def strtobool (val):
  300.     """Convert a string representation of truth to true (1) or false (0).
  301.     True values are 'y', 'yes', 't', 'true', 'on', and '1'; false values
  302.     are 'n', 'no', 'f', 'false', 'off', and '0'.  Raises ValueError if
  303.     'val' is anything else.
  304.     """
  305.     val = string.lower(val)
  306.     if val in ('y', 'yes', 't', 'true', 'on', '1'):
  307.         return 1
  308.     elif val in ('n', 'no', 'f', 'false', 'off', '0'):
  309.         return 0
  310.     else:
  311.         raise ValueError, "invalid truth value %s" % `val`
  312.  
  313.  
  314. def byte_compile (py_files,
  315.                   optimize=0, force=0,
  316.                   prefix=None, base_dir=None,
  317.                   verbose=1, dry_run=0,
  318.                   direct=None):
  319.     """Byte-compile a collection of Python source files to either .pyc
  320.     or .pyo files in the same directory.  'py_files' is a list of files
  321.     to compile; any files that don't end in ".py" are silently skipped.
  322.     'optimize' must be one of the following:
  323.       0 - don't optimize (generate .pyc)
  324.       1 - normal optimization (like "python -O")
  325.       2 - extra optimization (like "python -OO")
  326.     If 'force' is true, all files are recompiled regardless of
  327.     timestamps.
  328.  
  329.     The source filename encoded in each bytecode file defaults to the
  330.     filenames listed in 'py_files'; you can modify these with 'prefix' and
  331.     'basedir'.  'prefix' is a string that will be stripped off of each
  332.     source filename, and 'base_dir' is a directory name that will be
  333.     prepended (after 'prefix' is stripped).  You can supply either or both
  334.     (or neither) of 'prefix' and 'base_dir', as you wish.
  335.  
  336.     If 'verbose' is true, prints out a report of each file.  If 'dry_run'
  337.     is true, doesn't actually do anything that would affect the filesystem.
  338.  
  339.     Byte-compilation is either done directly in this interpreter process
  340.     with the standard py_compile module, or indirectly by writing a
  341.     temporary script and executing it.  Normally, you should let
  342.     'byte_compile()' figure out to use direct compilation or not (see
  343.     the source for details).  The 'direct' flag is used by the script
  344.     generated in indirect mode; unless you know what you're doing, leave
  345.     it set to None.
  346.     """
  347.  
  348.     # First, if the caller didn't force us into direct or indirect mode,
  349.     # figure out which mode we should be in.  We take a conservative
  350.     # approach: choose direct mode *only* if the current interpreter is
  351.     # in debug mode and optimize is 0.  If we're not in debug mode (-O
  352.     # or -OO), we don't know which level of optimization this
  353.     # interpreter is running with, so we can't do direct
  354.     # byte-compilation and be certain that it's the right thing.  Thus,
  355.     # always compile indirectly if the current interpreter is in either
  356.     # optimize mode, or if either optimization level was requested by
  357.     # the caller.
  358.     if direct is None:
  359.         direct = (__debug__ and optimize == 0)
  360.  
  361.     # "Indirect" byte-compilation: write a temporary script and then
  362.     # run it with the appropriate flags.
  363.     if not direct:
  364.         from tempfile import mktemp
  365.         script_name = mktemp(".py")
  366.         if verbose:
  367.             print "writing byte-compilation script '%s'" % script_name
  368.         if not dry_run:
  369.             script = open(script_name, "w")
  370.  
  371.             script.write("""\
  372. from distutils.util import byte_compile
  373. files = [
  374. """)
  375.  
  376.             # XXX would be nice to write absolute filenames, just for
  377.             # safety's sake (script should be more robust in the face of
  378.             # chdir'ing before running it).  But this requires abspath'ing
  379.             # 'prefix' as well, and that breaks the hack in build_lib's
  380.             # 'byte_compile()' method that carefully tacks on a trailing
  381.             # slash (os.sep really) to make sure the prefix here is "just
  382.             # right".  This whole prefix business is rather delicate -- the
  383.             # problem is that it's really a directory, but I'm treating it
  384.             # as a dumb string, so trailing slashes and so forth matter.
  385.  
  386.             #py_files = map(os.path.abspath, py_files)
  387.             #if prefix:
  388.             #    prefix = os.path.abspath(prefix)
  389.  
  390.             script.write(string.join(map(repr, py_files), ",\n") + "]\n")
  391.             script.write("""
  392. byte_compile(files, optimize=%s, force=%s,
  393.              prefix=%s, base_dir=%s,
  394.              verbose=%s, dry_run=0,
  395.              direct=1)
  396. """ % (`optimize`, `force`, `prefix`, `base_dir`, `verbose`))
  397.  
  398.             script.close()
  399.  
  400.         cmd = [sys.executable, script_name]
  401.         if optimize == 1:
  402.             cmd.insert(1, "-O")
  403.         elif optimize == 2:
  404.             cmd.insert(1, "-OO")
  405.         spawn(cmd, verbose=verbose, dry_run=dry_run)
  406.         execute(os.remove, (script_name,), "removing %s" % script_name,
  407.                 verbose=verbose, dry_run=dry_run)
  408.  
  409.     # "Direct" byte-compilation: use the py_compile module to compile
  410.     # right here, right now.  Note that the script generated in indirect
  411.     # mode simply calls 'byte_compile()' in direct mode, a weird sort of
  412.     # cross-process recursion.  Hey, it works!
  413.     else:
  414.         from py_compile import compile
  415.  
  416.         for file in py_files:
  417.             if file[-3:] != ".py":
  418.                 # This lets us be lazy and not filter filenames in
  419.                 # the "install_lib" command.
  420.                 continue
  421.  
  422.             # Terminology from the py_compile module:
  423.             #   cfile - byte-compiled file
  424.             #   dfile - purported source filename (same as 'file' by default)
  425.             cfile = file + (__debug__ and "c" or "o")
  426.             dfile = file
  427.             if prefix:
  428.                 if file[:len(prefix)] != prefix:
  429.                     raise ValueError, \
  430.                           ("invalid prefix: filename %s doesn't start with %s"
  431.                            % (`file`, `prefix`))
  432.                 dfile = dfile[len(prefix):]
  433.             if base_dir:
  434.                 dfile = os.path.join(base_dir, dfile)
  435.  
  436.             cfile_base = os.path.basename(cfile)
  437.             if direct:
  438.                 if force or newer(file, cfile):
  439.                     if verbose:
  440.                         print "byte-compiling %s to %s" % (file, cfile_base)
  441.                     if not dry_run:
  442.                         compile(file, cfile, dfile)
  443.                 else:
  444.                     if verbose:
  445.                         print "skipping byte-compilation of %s to %s" % \
  446.                               (file, cfile_base)
  447.  
  448. # byte_compile ()
  449.  
  450. def rfc822_escape (header):
  451.     """Return a version of the string escaped for inclusion in an
  452.     RFC-822 header, by ensuring there are 8 spaces space after each newline.
  453.     """
  454.     lines = string.split(header, '\n')
  455.     lines = map(string.strip, lines)
  456.     header = string.join(lines, '\n' + 8*' ')
  457.     return header
  458.