Home | History | Annotate | Download | only in python2.7 
      1 # Module 'os2emxpath' -- common operations on OS/2 pathnames
      2 """Common pathname manipulations, OS/2 EMX version.
      3 
      4 Instead of importing this module directly, import os and refer to this
      5 module as os.path.
      6 """
      7 
      8 import os
      9 import stat
     10 from genericpath import *
     11 from ntpath import (expanduser, expandvars, isabs, islink, splitdrive,
     12                     splitext, split, walk)
     13 
     14 __all__ = ["normcase","isabs","join","splitdrive","split","splitext",
     15            "basename","dirname","commonprefix","getsize","getmtime",
     16            "getatime","getctime", "islink","exists","lexists","isdir","isfile",
     17            "ismount","walk","expanduser","expandvars","normpath","abspath",
     18            "splitunc","curdir","pardir","sep","pathsep","defpath","altsep",
     19            "extsep","devnull","realpath","supports_unicode_filenames"]
     20 
     21 # strings representing various path-related bits and pieces
     22 curdir = '.'
     23 pardir = '..'
     24 extsep = '.'
     25 sep = '/'
     26 altsep = '\\'
     27 pathsep = ';'
     28 defpath = '.;C:\\bin'
     29 devnull = 'nul'
     30 
     31 # Normalize the case of a pathname and map slashes to backslashes.
     32 # Other normalizations (such as optimizing '../' away) are not done
     33 # (this is done by normpath).
     34 
     35 def normcase(s):
     36     """Normalize case of pathname.
     37 
     38     Makes all characters lowercase and all altseps into seps."""
     39     return s.replace('\\', '/').lower()
     40 
     41 
     42 # Join two (or more) paths.
     43 
     44 def join(a, *p):
     45     """Join two or more pathname components, inserting sep as needed"""
     46     path = a
     47     for b in p:
     48         if isabs(b):
     49             path = b
     50         elif path == '' or path[-1:] in '/\\:':
     51             path = path + b
     52         else:
     53             path = path + '/' + b
     54     return path
     55 
     56 
     57 # Parse UNC paths
     58 def splitunc(p):
     59     """Split a pathname into UNC mount point and relative path specifiers.
     60 
     61     Return a 2-tuple (unc, rest); either part may be empty.
     62     If unc is not empty, it has the form '//host/mount' (or similar
     63     using backslashes).  unc+rest is always the input path.
     64     Paths containing drive letters never have an UNC part.
     65     """
     66     if p[1:2] == ':':
     67         return '', p # Drive letter present
     68     firstTwo = p[0:2]
     69     if firstTwo == '/' * 2 or firstTwo == '\\' * 2:
     70         # is a UNC path:
     71         # vvvvvvvvvvvvvvvvvvvv equivalent to drive letter
     72         # \\machine\mountpoint\directories...
     73         #           directory ^^^^^^^^^^^^^^^
     74         normp = normcase(p)
     75         index = normp.find('/', 2)
     76         if index == -1:
     77             ##raise RuntimeError, 'illegal UNC path: "' + p + '"'
     78             return ("", p)
     79         index = normp.find('/', index + 1)
     80         if index == -1:
     81             index = len(p)
     82         return p[:index], p[index:]
     83     return '', p
     84 
     85 
     86 # Return the tail (basename) part of a path.
     87 
     88 def basename(p):
     89     """Returns the final component of a pathname"""
     90     return split(p)[1]
     91 
     92 
     93 # Return the head (dirname) part of a path.
     94 
     95 def dirname(p):
     96     """Returns the directory component of a pathname"""
     97     return split(p)[0]
     98 
     99 
    100 # alias exists to lexists
    101 lexists = exists
    102 
    103 
    104 # Is a path a directory?
    105 
    106 # Is a path a mount point?  Either a root (with or without drive letter)
    107 # or an UNC path with at most a / or \ after the mount point.
    108 
    109 def ismount(path):
    110     """Test whether a path is a mount point (defined as root of drive)"""
    111     unc, rest = splitunc(path)
    112     if unc:
    113         return rest in ("", "/", "\\")
    114     p = splitdrive(path)[1]
    115     return len(p) == 1 and p[0] in '/\\'
    116 
    117 
    118 # Normalize a path, e.g. A//B, A/./B and A/foo/../B all become A/B.
    119 
    120 def normpath(path):
    121     """Normalize path, eliminating double slashes, etc."""
    122     path = path.replace('\\', '/')
    123     prefix, path = splitdrive(path)
    124     while path[:1] == '/':
    125         prefix = prefix + '/'
    126         path = path[1:]
    127     comps = path.split('/')
    128     i = 0
    129     while i < len(comps):
    130         if comps[i] == '.':
    131             del comps[i]
    132         elif comps[i] == '..' and i > 0 and comps[i-1] not in ('', '..'):
    133             del comps[i-1:i+1]
    134             i = i - 1
    135         elif comps[i] == '' and i > 0 and comps[i-1] != '':
    136             del comps[i]
    137         else:
    138             i = i + 1
    139     # If the path is now empty, substitute '.'
    140     if not prefix and not comps:
    141         comps.append('.')
    142     return prefix + '/'.join(comps)
    143 
    144 
    145 # Return an absolute path.
    146 def abspath(path):
    147     """Return the absolute version of a path"""
    148     if not isabs(path):
    149         if isinstance(path, unicode):
    150             cwd = os.getcwdu()
    151         else:
    152             cwd = os.getcwd()
    153         path = join(cwd, path)
    154     return normpath(path)
    155 
    156 # realpath is a no-op on systems without islink support
    157 realpath = abspath
    158 
    159 supports_unicode_filenames = False
    160