+++ /dev/null
-"""Common operations on DOS pathnames."""
-
-import os
-import stat
-
-__all__ = ["normcase","isabs","join","splitdrive","split","splitext",
- "basename","dirname","commonprefix","getsize","getmtime",
- "getatime","islink","exists","isdir","isfile","ismount",
- "walk","expanduser","expandvars","normpath","abspath",
- "supports_unicode_filenames"]
-
-def normcase(s):
- """Normalize the case of a pathname.
- On MS-DOS it maps the pathname to lowercase, turns slashes into
- backslashes.
- Other normalizations (such as optimizing '../' away) are not allowed
- (this is done by normpath).
- Previously, this version mapped invalid consecutive characters to a
- single '_', but this has been removed. This functionality should
- possibly be added as a new function."""
-
- return s.replace("/", "\\").lower()
-
-
-def isabs(s):
- """Return whether a path is absolute.
- Trivial in Posix, harder on the Mac or MS-DOS.
- For DOS it is absolute if it starts with a slash or backslash (current
- volume), or if a pathname after the volume letter and colon starts with
- a slash or backslash."""
-
- s = splitdrive(s)[1]
- return s != '' and s[:1] in '/\\'
-
-
-def join(a, *p):
- """Join two (or more) paths."""
-
- path = a
- for b in p:
- if isabs(b):
- path = b
- elif path == '' or path[-1:] in '/\\:':
- path = path + b
- else:
- path = path + "\\" + b
- return path
-
-
-def splitdrive(p):
- """Split a path into a drive specification (a drive letter followed
- by a colon) and path specification.
- It is always true that drivespec + pathspec == p."""
-
- if p[1:2] == ':':
- return p[0:2], p[2:]
- return '', p
-
-
-def split(p):
- """Split a path into head (everything up to the last '/') and tail
- (the rest). After the trailing '/' is stripped, the invariant
- join(head, tail) == p holds.
- The resulting head won't end in '/' unless it is the root."""
-
- d, p = splitdrive(p)
- # set i to index beyond p's last slash
- i = len(p)
- while i and p[i-1] not in '/\\':
- i = i - 1
- head, tail = p[:i], p[i:] # now tail has no slashes
- # remove trailing slashes from head, unless it's all slashes
- head2 = head
- while head2 and head2[-1] in '/\\':
- head2 = head2[:-1]
- head = head2 or head
- return d + head, tail
-
-
-def splitext(p):
- """Split a path into root and extension.
- The extension is everything starting at the first dot in the last
- pathname component; the root is everything before that.
- It is always true that root + ext == p."""
-
- root, ext = '', ''
- for c in p:
- if c in '/\\':
- root, ext = root + ext + c, ''
- elif c == '.' or ext:
- ext = ext + c
- else:
- root = root + c
- return root, ext
-
-
-def basename(p):
- """Return the tail (basename) part of a path."""
-
- return split(p)[1]
-
-
-def dirname(p):
- """Return the head (dirname) part of a path."""
-
- return split(p)[0]
-
-
-def commonprefix(m):
- """Return the longest prefix of all list elements."""
-
- if not m: return ''
- prefix = m[0]
- for item in m:
- for i in range(len(prefix)):
- if prefix[:i+1] != item[:i+1]:
- prefix = prefix[:i]
- if i == 0: return ''
- break
- return prefix
-
-
-# Get size, mtime, atime of files.
-
-def getsize(filename):
- """Return the size of a file, reported by os.stat()."""
- return os.stat(filename).st_size
-
-def getmtime(filename):
- """Return the last modification time of a file, reported by os.stat()."""
- return os.stat(filename).st_mtime
-
-def getatime(filename):
- """Return the last access time of a file, reported by os.stat()."""
-
- return os.stat(filename).st_atime
-
-def islink(path):
- """Is a path a symbolic link?
- This will always return false on systems where posix.lstat doesn't exist."""
-
- return False
-
-
-def exists(path):
- """Does a path exist?
- This is false for dangling symbolic links."""
-
- try:
- st = os.stat(path)
- except os.error:
- return False
- return True
-
-
-def isdir(path):
- """Is a path a dos directory?"""
-
- try:
- st = os.stat(path)
- except os.error:
- return False
- return stat.S_ISDIR(st.st_mode)
-
-
-def isfile(path):
- """Is a path a regular file?"""
-
- try:
- st = os.stat(path)
- except os.error:
- return False
- return stat.S_ISREG(st.st_mode)
-
-
-def ismount(path):
- """Is a path a mount point?"""
- # XXX This degenerates in: 'is this the root?' on DOS
-
- return isabs(splitdrive(path)[1])
-
-
-def walk(top, func, arg):
- """Directory tree walk with callback function.
-
- For each directory in the directory tree rooted at top (including top
- itself, but excluding '.' and '..'), call func(arg, dirname, fnames).
- dirname is the name of the directory, and fnames a list of the names of
- the files and subdirectories in dirname (excluding '.' and '..'). func
- may modify the fnames list in-place (e.g. via del or slice assignment),
- and walk will only recurse into the subdirectories whose names remain in
- fnames; this can be used to implement a filter, or to impose a specific
- order of visiting. No semantics are defined for, or required of, arg,
- beyond that arg is always passed to func. It can be used, e.g., to pass
- a filename pattern, or a mutable object designed to accumulate
- statistics. Passing None for arg is common."""
-
- try:
- names = os.listdir(top)
- except os.error:
- return
- func(arg, top, names)
- exceptions = ('.', '..')
- for name in names:
- if name not in exceptions:
- name = join(top, name)
- if isdir(name):
- walk(name, func, arg)
-
-
-def expanduser(path):
- """Expand paths beginning with '~' or '~user'.
- '~' means $HOME; '~user' means that user's home directory.
- If the path doesn't begin with '~', or if the user or $HOME is unknown,
- the path is returned unchanged (leaving error reporting to whatever
- function is called with the expanded path as argument).
- See also module 'glob' for expansion of *, ? and [...] in pathnames.
- (A function should also be defined to do full *sh-style environment
- variable expansion.)"""
-
- if path[:1] != '~':
- return path
- i, n = 1, len(path)
- while i < n and path[i] not in '/\\':
- i = i+1
- if i == 1:
- if not 'HOME' in os.environ:
- return path
- userhome = os.environ['HOME']
- else:
- return path
- return userhome + path[i:]
-
-
-def expandvars(path):
- """Expand paths containing shell variable substitutions.
- The following rules apply:
- - no expansion within single quotes
- - no escape character, except for '$$' which is translated into '$'
- - ${varname} is accepted.
- - varnames can be made out of letters, digits and the character '_'"""
- # XXX With COMMAND.COM you can use any characters in a variable name,
- # XXX except '^|<>='.
-
- if '$' not in path:
- return path
- import string
- varchars = string.ascii_letters + string.digits + "_-"
- res = ''
- index = 0
- pathlen = len(path)
- while index < pathlen:
- c = path[index]
- if c == '\'': # no expansion within single quotes
- path = path[index + 1:]
- pathlen = len(path)
- try:
- index = path.index('\'')
- res = res + '\'' + path[:index + 1]
- except ValueError:
- res = res + path
- index = pathlen -1
- elif c == '$': # variable or '$$'
- if path[index + 1:index + 2] == '$':
- res = res + c
- index = index + 1
- elif path[index + 1:index + 2] == '{':
- path = path[index+2:]
- pathlen = len(path)
- try:
- index = path.index('}')
- var = path[:index]
- if var in os.environ:
- res = res + os.environ[var]
- except ValueError:
- res = res + path
- index = pathlen - 1
- else:
- var = ''
- index = index + 1
- c = path[index:index + 1]
- while c != '' and c in varchars:
- var = var + c
- index = index + 1
- c = path[index:index + 1]
- if var in os.environ:
- res = res + os.environ[var]
- if c != '':
- res = res + c
- else:
- res = res + c
- index = index + 1
- return res
-
-
-def normpath(path):
- """Normalize a path, e.g. A//B, A/./B and A/foo/../B all become A/B.
- Also, components of the path are silently truncated to 8+3 notation."""
-
- path = path.replace("/", "\\")
- prefix, path = splitdrive(path)
- while path[:1] == "\\":
- prefix = prefix + "\\"
- path = path[1:]
- comps = path.split("\\")
- i = 0
- while i < len(comps):
- if comps[i] == '.':
- del comps[i]
- elif comps[i] == '..' and i > 0 and \
- comps[i-1] not in ('', '..'):
- del comps[i-1:i+1]
- i = i - 1
- elif comps[i] == '' and i > 0 and comps[i-1] != '':
- del comps[i]
- elif '.' in comps[i]:
- comp = comps[i].split('.')
- comps[i] = comp[0][:8] + '.' + comp[1][:3]
- i = i + 1
- elif len(comps[i]) > 8:
- comps[i] = comps[i][:8]
- i = i + 1
- else:
- i = i + 1
- # If the path is now empty, substitute '.'
- if not prefix and not comps:
- comps.append('.')
- return prefix + "\\".join(comps)
-
-
-
-def abspath(path):
- """Return an absolute path."""
- if not isabs(path):
- path = join(os.getcwd(), path)
- return normpath(path)
-
-# realpath is a no-op on systems without islink support
-realpath = abspath
-supports_unicode_filenames = False
r"""OS routines for Mac, DOS, NT, or Posix depending on what system we're on.
This exports:
- - all functions from posix, nt, dos, os2, mac, or ce, e.g. unlink, stat, etc.
- - os.path is one of the modules posixpath, ntpath, macpath, or dospath
- - os.name is 'posix', 'nt', 'dos', 'os2', 'mac', 'ce' or 'riscos'
+ - all functions from posix, nt, os2, mac, or ce, e.g. unlink, stat, etc.
+ - os.path is one of the modules posixpath, ntpath, or macpath
+ - os.name is 'posix', 'nt', 'os2', 'mac', 'ce' or 'riscos'
- os.curdir is a string representing the current directory ('.' or ':')
- os.pardir is a string representing the parent directory ('..' or '::')
- os.sep is the (or a most common) pathname separator ('/' or ':' or '\\')
__all__.extend(_get_exports_list(nt))
del nt
-elif 'dos' in _names:
- name = 'dos'
- linesep = '\r\n'
- curdir = '.'; pardir = '..'; sep = '\\'; pathsep = ';'
- defpath = '.;C:\\bin'
- from dos import *
- try:
- from dos import _exit
- except ImportError:
- pass
- import dospath
- path = dospath
- del dospath
-
- import dos
- __all__.extend(_get_exports_list(dos))
- del dos
-
elif 'os2' in _names:
name = 'os2'
linesep = '\r\n'
import UserDict
# Fake unsetenv() for Windows
- # not sure about os2 and dos here but
+ # not sure about os2 here but
# I'm guessing they are the same.
- if name in ('os2', 'nt', 'dos'):
+ if name in ('os2', 'nt'):
def unsetenv(key):
putenv(key, "")
if name == "riscos":
# On RISC OS, all env access goes through getenv and putenv
from riscosenviron import _Environ
- elif name in ('os2', 'nt', 'dos'): # Where Env Var Names Must Be UPPERCASE
+ elif name in ('os2', 'nt'): # Where Env Var Names Must Be UPPERCASE
# But we store them as upper case
class _Environ(UserDict.IterableUserDict):
def __init__(self, environ):
projects / python / commitdiff