Changeset 3426

Timestamp:

Jun 14, 2007, 3:54:22 AM (18 years ago)

Author:

bird

Message:

os2knixpath.

Location:

trunk/essentials/dev-lang/python/Lib

Files:

• os.py (modified) (1 diff)
• os2knixpath.py (copied) (copied from trunk/essentials/dev-lang/python/Lib/os2emxpath.py ) (14 diffs)

trunk/essentials/dev-lang/python/Lib/os.py

@@ -75 +75 @@
     except ImportError:
         pass
-    # if sys.version.find('EMX GCC') == -1 and sys.platform != 'os2knix':
-    if sys.version.find('EMX GCC') == -1:
+    if sys.platform == 'os2knix':
+        import os2knixpath as path
+    elif sys.version.find('EMX GCC') == -1:
         import ntpath as path
     else:

trunk/essentials/dev-lang/python/Lib/os2knixpath.py

@@ -1 @@
-# Module 'os2emxpath' -- common operations on OS/2 pathnames
-"""Common pathname manipulations, OS/2 EMX version.
-
-Instead of importing this module directly, import os and refer to this
-module as os.path.
+"""Common operations on OS/2 kNIX pathnames.
+
+Instead of importing this module directly, import os and refer to
+this module as os.path.  The "os.path" name is an alias for this
+module on OS/2 kNIX Posix; on other systems (e.g. Mac, Windows),
+os.path provides the same operations in a manner specific to that
+platform, and is an alias to another module (e.g. macpath, ntpath).
+
+This is slightly different from both OS/2 EMX and POSIX, so in order
+to avoid messing up those sources, the kNIX code has got a separate 
+file that drags from both EMX and POSIX.
 """
 
@@ -11 +17 @@
 __all__ = ["normcase","isabs","join","splitdrive","split","splitext",
            "basename","dirname","commonprefix","getsize","getmtime",
-           "getatime","getctime", "islink","exists","lexists","isdir","isfile",
+           "getatime","getctime","islink","exists","lexists","isdir","isfile",
            "ismount","walk","expanduser","expandvars","normpath","abspath",
-           "splitunc","curdir","pardir","sep","pathsep","defpath","altsep",
-           "extsep","devnull","realpath","supports_unicode_filenames"]
+           "samefile","sameopenfile","samestat",
+           "curdir","pardir","sep","pathsep","defpath","altsep","extsep",
+           "devnull","realpath","supports_unicode_filenames",
+           "splitunc"]
 
 # strings representing various path-related bits and pieces
@@ -23 +31 @@
 altsep = '\\'
 pathsep = ';'
-defpath = '.;C:\\bin'
+defpath = '.;/@unixroot/bin;/@unixroot/usr/bin;/@unixroot/usr/local/bin'
 devnull = 'nul'
 
-# Normalize the case of a pathname and map slashes to backslashes.
-# Other normalizations (such as optimizing '../' away) are not done
-# (this is done by normpath).
+# Normalize the case of a pathname.  Trivial in Posix, string.lower on Mac.
+# On MS-DOS this may also turn slashes into backslashes; however, other
+# normalizations (such as optimizing '../' away) are not allowed
+# (another function should be defined to do that).
 
 def normcase(s):
     """Normalize case of pathname.
 
-    Makes all characters lowercase and all altseps into seps."""
-    return s.replace('\\', '/').lower()
+    XXX: This needs to call some kLIBC function to do case corrections, but 
+         I'm not up do that right now.
+    """
+    return s.replace('\\', '/')
 
 
@@ -49 +60 @@
 
 
-# Join two (or more) paths.
+# Join pathnames.
+# Ignore the previous parts if a part is absolute.
+# Insert a '/' unless the first part is empty or already ends in '/'.
 
 def join(a, *p):
-    """Join two or more pathname components, inserting sep as needed"""
+    """Join two or more pathname components, inserting '/' as needed"""
     path = a
     for b in p:
@@ -105 +118 @@
 
 # Split a path in 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.
+# rest).  If the path ends in '/', tail will be empty.  If there is no
+# '/' in the path, head  will be empty.
+# Trailing '/'es are stripped from head unless it is the root.
 
 def split(p):
-    """Split a pathname.
-
-    Return tuple (head, tail) where tail is everything after the final slash.
-    Either part may be empty."""
+    """Split a pathname.  Returns tuple "(head, tail)" where "tail" is
+    everything after the final slash.  Either part may be empty."""
 
     d, p = splitdrive(p)
@@ -182 +193 @@
     return s1[:n]
 
-
 # Get size, mtime, atime of files.
 
 def getsize(filename):
-    """Return the size of a file, reported by os.stat()"""
+    """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 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 the last access time of a file, reported by os.stat()."""
     return os.stat(filename).st_atime
 
 def getctime(filename):
-    """Return the creation time of a file, reported by os.stat()."""
+    """Return the metadata change time of a file, reported by os.stat()."""
     return os.stat(filename).st_ctime
 
 # Is a path a symbolic link?
-# This will always return false on systems where posix.lstat doesn't exist.
+# This will always return false on systems where os.lstat doesn't exist.
 
 def islink(path):
-    """Test for symbolic link.  On OS/2 always returns false"""
-    return False
+    """Test whether a path is a symbolic link"""
+    try:
+        st = os.lstat(path)
+    except (os.error, AttributeError):
+        return False
+    return stat.S_ISLNK(st.st_mode)
 
 
@@ -213 +227 @@
 
 def exists(path):
-    """Test whether a path exists"""
+    """Test whether a path exists.  Returns False for broken symbolic links"""
     try:
         st = os.stat(path)
@@ -220 +234 @@
     return True
 
-lexists = exists
+
+# Being true for dangling symbolic links is also useful.
+
+def lexists(path):
+    """Test whether a path exists.  Returns True for broken symbolic links"""
+    try:
+        st = os.lstat(path)
+    except os.error:
+        return False
+    return True
 
 
 # Is a path a directory?
+# This follows symbolic links, so both islink() and isdir() can be true
+# for the same path.
 
 def isdir(path):
@@ -235 +260 @@
 
 # Is a path a regular file?
-# This follows symbolic links, so both islink() and isdir() can be true
+# This follows symbolic links, so both islink() and isfile() can be true
 # for the same path.
 
@@ -247 +272 @@
 
 
+# Are two filenames really pointing to the same file?
+
+def samefile(f1, f2):
+    """Test whether two pathnames reference the same actual file"""
+    s1 = os.stat(f1)
+    s2 = os.stat(f2)
+    return samestat(s1, s2)
+
+
+# Are two open files really referencing the same file?
+# (Not necessarily the same file descriptor!)
+
+def sameopenfile(fp1, fp2):
+    """Test whether two open file objects reference the same file"""
+    s1 = os.fstat(fp1)
+    s2 = os.fstat(fp2)
+    return samestat(s1, s2)
+
+
+# Are two stat buffers (obtained from stat, fstat or lstat)
+# describing the same file?
+
+def samestat(s1, s2):
+    """Test whether two stat buffers reference the same file"""
+    return s1.st_ino == s2.st_ino and \
+           s1.st_dev == s2.st_dev
+
+
 # Is a path a mount point?  Either a root (with or without drive letter)
 # or an UNC path with at most a / or \ after the mount point.
 
 def ismount(path):
-    """Test whether a path is a mount point (defined as root of drive)"""
+    """Test whether a path is a mount point (defined as root of drive)
+    XXX: this isn't correct for if path is a symlink!
+    """
     unc, rest = splitunc(path)
     if unc:
@@ -268 +323 @@
 
 def walk(top, func, arg):
-    """Directory tree walk whth callback function.
-
-    walk(top, func, arg) calls func(arg, d, files) for each directory d
-    in the tree rooted at top (including top itself); files is a list
-    of all the files and subdirs in directory d."""
+    """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)
@@ -307 +370 @@
         if 'HOME' in os.environ:
             userhome = os.environ['HOME']
-        elif not 'HOMEPATH' in os.environ:
-            return path
-        else:
+        elif 'HOMEPATH' in os.environ:
             try:
                 drive = os.environ['HOMEDRIVE']
@@ -315 +376 @@
                 drive = ''
             userhome = join(drive, os.environ['HOMEPATH'])
+        else:
+            import pwd
+            userhome = pwd.getpwuid(os.getuid()).pw_dir
     else:
-        return path
+        import pwd
+        try:
+            pwent = pwd.getpwnam(path[1:i])
+        except KeyError:
+            return path
+        userhome = pwent.pw_dir
+
+    if userhome.endswith('/') or userhome.endswith('\\'):
+        i += 1
     return userhome + path[i:]
 
@@ -418 +490 @@
     return normpath(path)
 
-# realpath is a no-op on systems without islink support
-realpath = abspath
+
+# Return a canonical path (i.e. the absolute location of a file on the
+# filesystem).
+
+def realpath(filename):
+    """Return the canonical path of the specified filename, eliminating any
+symbolic links encountered in the path."""
+    filename.replace('\\', '/') # simpler this way..
+    if isabs(filename):
+        bits = ['/'] + filename.split('/')[1:]
+    else:
+        bits = [''] + filename.split('/')
+
+    for i in range(2, len(bits)+1):
+        component = join(*bits[0:i])
+        # Resolve symbolic links.
+        if islink(component):
+            resolved = _resolve_link(component)
+            if resolved is None:
+                # Infinite loop -- return original component + rest of the path
+                return abspath(join(*([component] + bits[i:])))
+            else:
+                newpath = join(*([resolved] + bits[i:]))
+                return realpath(newpath)
+
+    return abspath(filename)
+
+
+def _resolve_link(path):
+    """Internal helper function.  Takes a path and follows symlinks
+    until we either arrive at something that isn't a symlink, or
+    encounter a path we've seen before (meaning that there's a loop).
+    """
+    paths_seen = []
+    while islink(path):
+        if path in paths_seen:
+            # Already seen this path, so we must have a symlink loop
+            return None
+        paths_seen.append(path)
+        # Resolve where the link points to
+        resolved = os.readlink(path)
+        if not isabs(resolved):
+            dir = dirname(path)
+            path = normpath(join(dir, resolved))
+        else:
+            path = normpath(resolved)
+    return path
 
 supports_unicode_filenames = False
+