home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / pyos2bin.zip / Lib / macpath.py < prev    next >
Text File  |  1997-05-21  |  4KB  |  197 lines
  1. # module 'macpath' -- pathname (or -related) operations for the Macintosh
  2.  
  3. import string
  4. import mac
  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. # Return true if a path is absolute.
  14. # On the Mac, relative paths begin with a colon,
  15. # but as a special case, paths with no colons at all are also relative.
  16. # Anything else is absolute (the string up to the first colon is the
  17. # volume name).
  18.  
  19. def isabs(s):
  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. # Split a pathname in two parts: the directory leading up to the final bit,
  40. # and the basename (the filename, without colons, in that directory).
  41. # The result (s, t) is such that join(s, t) yields the original argument.
  42.  
  43. def split(s):
  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. # Split a path in root and extension.
  55. # The extension is everything starting at the last dot in the last
  56. # pathname component; the root is everything before that.
  57. # It is always true that root + ext == p.
  58.  
  59. def splitext(p):
  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. # Split a pathname into a drive specification and the rest of the
  77. # path.  Useful on DOS/Windows/NT; on the Mac, the drive is always
  78. # empty (don't use the volume name -- it doesn't have the same
  79. # syntactic and semantic oddities as DOS drive letters, such as there
  80. # being a separate current directory per drive).
  81.  
  82. def splitdrive(p):
  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. # Return true if the pathname refers to an existing directory.
  93.  
  94. def isdir(s):
  95.     try:
  96.         st = mac.stat(s)
  97.     except mac.error:
  98.         return 0
  99.     return S_ISDIR(st[ST_MODE])
  100.  
  101.  
  102. # Return true if the pathname refers to a symbolic link.
  103. # (Always false on the Mac, until we understand Aliases.)
  104.  
  105. def islink(s):
  106.     return 0
  107.  
  108.  
  109. # Return true if the pathname refers to an existing regular file.
  110.  
  111. def isfile(s):
  112.     try:
  113.         st = mac.stat(s)
  114.     except mac.error:
  115.         return 0
  116.     return S_ISREG(st[ST_MODE])
  117.  
  118.  
  119. # Return true if the pathname refers to an existing file or directory.
  120.  
  121. def exists(s):
  122.     try:
  123.         st = mac.stat(s)
  124.     except mac.error:
  125.         return 0
  126.     return 1
  127.  
  128. #
  129. # dummy expandvars to retain interface-compatability with other
  130. # operating systems.
  131. def expandvars(path):
  132.     return path
  133.  
  134. #
  135. # dummy expanduser to retain interface-compatability with other
  136. # operating systems.
  137. def expanduser(path):
  138.     return path
  139.  
  140. # Normalize a pathname: get rid of '::' sequences by backing up,
  141. # e.g., 'foo:bar::bletch' becomes 'foo:bletch'.
  142. # Raise the exception norm_error below if backing up is impossible,
  143. # e.g., for '::foo'.
  144. # XXX The Unix version doesn't raise an exception but simply
  145. # returns an unnormalized path.  Should do so here too.
  146.  
  147. norm_error = 'macpath.norm_error: path cannot be normalized'
  148.  
  149. def normpath(s):
  150.     import string
  151.     if ':' not in s:
  152.         return ':' + s
  153.     f = string.splitfields(s, ':')
  154.     pre = []
  155.     post = []
  156.     if not f[0]:
  157.         pre = f[:1]
  158.         f = f[1:]
  159.     if not f[len(f)-1]:
  160.         post = f[-1:]
  161.         f = f[:-1]
  162.     res = []
  163.     for seg in f:
  164.         if seg:
  165.             res.append(seg)
  166.         else:
  167.             if not res: raise norm_error, 'path starts with ::'
  168.             del res[len(res)-1]
  169.             if not (pre or res):
  170.                 raise norm_error, 'path starts with volume::'
  171.     if pre: res = pre + res
  172.     if post: res = res + post
  173.     s = res[0]
  174.     for seg in res[1:]:
  175.         s = s + ':' + seg
  176.     return s
  177.  
  178.  
  179. # Directory tree walk.
  180. # For each directory under top (including top itself),
  181. # func(arg, dirname, filenames) is called, where
  182. # dirname is the name of the directory and filenames is the list
  183. # of files (and subdirectories etc.) in the directory.
  184. # The func may modify the filenames list, to implement a filter,
  185. # or to impose a different order of visiting.
  186.  
  187. def walk(top, func, arg):
  188.     try:
  189.         names = mac.listdir(top)
  190.     except mac.error:
  191.         return
  192.     func(arg, top, names)
  193.     for name in names:
  194.         name = join(top, name)
  195.         if isdir(name):
  196.             walk(name, func, arg)
  197.