Lib/macpath.py

   1 """Pathname and path-related operations for the Macintosh."""
   2
   3 import string
   4 import os
   5 from stat import *
   6
   7
   8 # Normalize the case of a pathname.  Dummy in Posix, but string.lower here.
   9
  10 normcase = string.lower
  11
  12
  13 def isabs(s):
  14     """Return true if a path is absolute.
  15     On the Mac, relative paths begin with a colon,
  16     but as a special case, paths with no colons at all are also relative.
  17     Anything else is absolute (the string up to the first colon is the
  18     volume name)."""
  19
  20     return ':' in s and s[0] <> ':'
  21
  22
  23 def join(s, *p):
  24     path = s
  25     for t in p:
  26         if (not s) or isabs(t):
  27             path = t
  28             continue
  29         if t[:1] == ':':
  30             t = t[1:]
  31         if ':' not in path:
  32             path = ':' + path
  33         if path[-1:] <> ':':
  34             path = path + ':'
  35         path = path + t
  36     return path
  37
  38
  39 def split(s):
  40     """Split a pathname into two parts: the directory leading up to the final
  41     bit, and the basename (the filename, without colons, in that directory).
  42     The result (s, t) is such that join(s, t) yields the original argument."""
  43
  44     if ':' not in s: return '', s
  45     colon = 0
  46     for i in range(len(s)):
  47         if s[i] == ':': colon = i+1
  48     path, file = s[:colon-1], s[colon:]
  49     if path and not ':' in path:
  50         path = path + ':'
  51     return path, file
  52
  53
  54 def splitext(p):
  55     """Split a path into root and extension.
  56     The extension is everything starting at the last dot in the last
  57     pathname component; the root is everything before that.
  58     It is always true that root + ext == p."""
  59
  60     root, ext = '', ''
  61     for c in p:
  62         if c == ':':
  63             root, ext = root + ext + c, ''
  64         elif c == '.':
  65             if ext:
  66                 root, ext = root + ext, c
  67             else:
  68                 ext = c
  69         elif ext:
  70             ext = ext + c
  71         else:
  72             root = root + c
  73     return root, ext
  74
  75
  76 def splitdrive(p):
  77     """Split a pathname into a drive specification and the rest of the
  78     path.  Useful on DOS/Windows/NT; on the Mac, the drive is always
  79     empty (don't use the volume name -- it doesn't have the same
  80     syntactic and semantic oddities as DOS drive letters, such as there
  81     being a separate current directory per drive)."""
  82
  83     return '', p
  84
  85
  86 # Short interfaces to split()
  87
  88 def dirname(s): return split(s)[0]
  89 def basename(s): return split(s)[1]
  90
  91
  92 def isdir(s):
  93     """Return true if the pathname refers to an existing directory."""
  94
  95     try:
  96         st = os.stat(s)
  97     except os.error:
  98         return 0
  99     return S_ISDIR(st[ST_MODE])
 100
 101
 102 # Get size, mtime, atime of files.
 103
 104 def getsize(filename):
 105     """Return the size of a file, reported by os.stat()."""
 106     st = os.stat(filename)
 107     return st[ST_SIZE]
 108
 109 def getmtime(filename):
 110     """Return the last modification time of a file, reported by os.stat()."""
 111     st = os.stat(filename)
 112     return st[ST_MTIME]
 113
 114 def getatime(filename):
 115     """Return the last access time of a file, reported by os.stat()."""
 116     st = os.stat(filename)
 117     return st[ST_MTIME]
 118
 119
 120 def islink(s):
 121     """Return true if the pathname refers to a symbolic link.
 122     Always false on the Mac, until we understand Aliases.)"""
 123
 124     return 0
 125
 126
 127 def isfile(s):
 128     """Return true if the pathname refers to an existing regular file."""
 129
 130     try:
 131         st = os.stat(s)
 132     except os.error:
 133         return 0
 134     return S_ISREG(st[ST_MODE])
 135
 136
 137 def exists(s):
 138     """Return true if the pathname refers to an existing file or directory."""
 139
 140     try:
 141         st = os.stat(s)
 142     except os.error:
 143         return 0
 144     return 1
 145
 146
 147 def expandvars(path):
 148     """Dummy to retain interface-compatibility with other operating systems."""
 149     return path
 150
 151
 152 def expanduser(path):
 153     """Dummy to retain interface-compatibility with other operating systems."""
 154     return path
 155
 156 norm_error = 'macpath.norm_error: path cannot be normalized'
 157
 158 def normpath(s):
 159     """Normalize a pathname: get rid of '::' sequences by backing up,
 160     e.g., 'foo:bar::bletch' becomes 'foo:bletch'.
 161     Raise the exception norm_error below if backing up is impossible,
 162     e.g., for '::foo'."""
 163     # XXX The Unix version doesn't raise an exception but simply
 164     # returns an unnormalized path.  Should do so here too.
 165
 166     import string
 167     if ':' not in s:
 168         return ':' + s
 169     f = string.splitfields(s, ':')
 170     pre = []
 171     post = []
 172     if not f[0]:
 173         pre = f[:1]
 174         f = f[1:]
 175     if not f[len(f)-1]:
 176         post = f[-1:]
 177         f = f[:-1]
 178     res = []
 179     for seg in f:
 180         if seg:
 181             res.append(seg)
 182         else:
 183             if not res: raise norm_error, 'path starts with ::'
 184             del res[len(res)-1]
 185             if not (pre or res):
 186                 raise norm_error, 'path starts with volume::'
 187     if pre: res = pre + res
 188     if post: res = res + post
 189     s = res[0]
 190     for seg in res[1:]:
 191         s = s + ':' + seg
 192     return s
 193
 194
 195 def walk(top, func, arg):
 196     """Directory tree walk.
 197     For each directory under top (including top itself),
 198     func(arg, dirname, filenames) is called, where
 199     dirname is the name of the directory and filenames is the list
 200     of files (and subdirectories etc.) in the directory.
 201     The func may modify the filenames list, to implement a filter,
 202     or to impose a different order of visiting."""
 203
 204     try:
 205         names = os.listdir(top)
 206     except os.error:
 207         return
 208     func(arg, top, names)
 209     for name in names:
 210         name = join(top, name)
 211         if isdir(name):
 212             walk(name, func, arg)
 213
 214
 215 def abspath(path):
 216     """Return an absolute path."""
 217     if not isabs(path):
 218         path = join(os.getcwd(), path)
 219     return normpath(path)