Lib/plat-riscos/riscospath.py

   1 # Module 'riscospath' -- common operations on RISC OS pathnames.
   2
   3 # contributed by Andrew Clover  ( andrew@oaktree.co.uk )
   4
   5 # The "os.path" name is an alias for this module on RISC OS systems;
   6 # on other systems (e.g. Mac, Windows), os.path provides the same
   7 # operations in a manner specific to that platform, and is an alias
   8 # to another module (e.g. macpath, ntpath).
   9
  10 """
  11 Instead of importing this module directly, import os and refer to this module
  12 as os.path.
  13 """
  14
  15 # strings representing various path-related bits and pieces
  16 curdir = '@'
  17 pardir = '^'
  18 extsep = '/'
  19 sep = '.'
  20 pathsep = ','
  21 defpath = '<Run$Dir>'
  22 altsep = None
  23
  24 # Imports - make an error-generating swi object if the swi module is not
  25 # available (ie. we are not running on RISC OS Python)
  26
  27 import os, stat, string
  28
  29 try:
  30     import swi
  31 except ImportError:
  32     class _swi:
  33         def swi(*a):
  34             raise AttributeError, 'This function only available under RISC OS'
  35         block= swi
  36     swi= _swi()
  37
  38 [_false, _true]= range(2)
  39
  40 _roots= ['$', '&', '%', '@', '\\']
  41
  42
  43 # _allowMOSFSNames
  44 # After importing riscospath, set _allowMOSFSNames true if you want the module
  45 # to understand the "-SomeFS-" notation left over from the old BBC Master MOS,
  46 # as well as the standard "SomeFS:" notation. Set this to be fully backwards
  47 # compatible but remember that "-SomeFS-" can also be a perfectly valid file
  48 # name so care must be taken when splitting and joining paths.
  49
  50 _allowMOSFSNames= _false
  51
  52
  53 ## Path manipulation, RISC OS stylee.
  54
  55 def _split(p):
  56     """
  57   split filing system name (including special field) and drive specifier from rest
  58   of path. This is needed by many riscospath functions.
  59   """
  60     dash= _allowMOSFSNames and p[:1]=='-'
  61     if dash:
  62         q= string.find(p, '-', 1)+1
  63     else:
  64         if p[:1]==':':
  65             q= 0
  66         else:
  67             q= string.find(p, ':')+1 # q= index of start of non-FS portion of path
  68     s= string.find(p, '#')
  69     if s==-1 or s>q:
  70         s= q # find end of main FS name, not including special field
  71     else:
  72         for c in p[dash:s]:
  73             if c not in string.ascii_letters:
  74                 q= 0
  75                 break # disallow invalid non-special-field characters in FS name
  76     r= q
  77     if p[q:q+1]==':':
  78         r= string.find(p, '.', q+1)+1
  79         if r==0:
  80             r= len(p) # find end of drive name (if any) following FS name (if any)
  81     return (p[:q], p[q:r], p[r:])
  82
  83
  84 def normcase(p):
  85     """
  86   Normalize the case of a pathname. This converts to lowercase as the native RISC
  87   OS filesystems are case-insensitive. However, not all filesystems have to be,
  88   and there's no simple way to find out what type an FS is argh.
  89   """
  90     return string.lower(p)
  91
  92
  93 def isabs(p):
  94     """
  95   Return whether a path is absolute. Under RISC OS, a file system specifier does
  96   not make a path absolute, but a drive name or number does, and so does using the
  97   symbol for root, URD, library, CSD or PSD. This means it is perfectly possible
  98   to have an "absolute" URL dependent on the current working directory, and
  99   equally you can have a "relative" URL that's on a completely different device to
 100   the current one argh.
 101   """
 102     (fs, drive, path)= _split(p)
 103     return drive!='' or path[:1] in _roots
 104
 105
 106 def join(a, *p):
 107     """
 108   Join path elements with the directory separator, replacing the entire path when
 109   an absolute or FS-changing path part is found.
 110   """
 111     j= a
 112     for b in p:
 113         (fs, drive, path)= _split(b)
 114         if j=='' or fs!='' or drive!='' or path[:1] in _roots:
 115             j= b
 116         elif j[-1]==':':
 117             j= j+b
 118         else:
 119             j= j+'.'+b
 120     return j
 121
 122
 123 def split(p):
 124     """
 125   Split a path in head (everything up to the last '.') and tail (the rest). FS
 126   name must still be dealt with separately since special field may contain '.'.
 127   """
 128     (fs, drive, path)= _split(p)
 129     q= string.rfind(path, '.')
 130     if q!=-1:
 131         return (fs+drive+path[:q], path[q+1:])
 132     return ('', p)
 133
 134
 135 def splitext(p):
 136     """
 137   Split a path in root and extension. This assumes the 'using slash for dot and
 138   dot for slash with foreign files' convention common in RISC OS is in force.
 139   """
 140     (tail, head)= split(p)
 141     if '/' in head:
 142         q= len(head)-string.rfind(head, '/')
 143         return (p[:-q], p[-q:])
 144     return (p, '')
 145
 146
 147 def splitdrive(p):
 148     """
 149   Split a pathname into a drive specification (including FS name) and the rest of
 150   the path. The terminating dot of the drive name is included in the drive
 151   specification.
 152   """
 153     (fs, drive, path)= _split(p)
 154     return (fs+drive, p)
 155
 156
 157 def basename(p):
 158     """
 159   Return the tail (basename) part of a path.
 160   """
 161     return split(p)[1]
 162
 163
 164 def dirname(p):
 165     """
 166   Return the head (dirname) part of a path.
 167   """
 168     return split(p)[0]
 169
 170
 171 def commonprefix(m):
 172     "Given a list of pathnames, returns the longest common leading component"
 173     if not m: return ''
 174     s1 = min(m)
 175     s2 = max(m)
 176     n = min(len(s1), len(s2))
 177     for i in xrange(n):
 178         if s1[i] != s2[i]:
 179             return s1[:i]
 180     return s1[:n]
 181
 182
 183 ## File access functions. Why are we in os.path?
 184
 185 def getsize(p):
 186     """
 187   Return the size of a file, reported by os.stat().
 188   """
 189     st= os.stat(p)
 190     return st[stat.ST_SIZE]
 191
 192
 193 def getmtime(p):
 194     """
 195   Return the last modification time of a file, reported by os.stat().
 196   """
 197     st = os.stat(p)
 198     return st[stat.ST_MTIME]
 199
 200 getatime= getmtime
 201
 202
 203 # RISC OS-specific file access functions
 204
 205 def exists(p):
 206     """
 207   Test whether a path exists.
 208   """
 209     try:
 210         return swi.swi('OS_File', '5s;i', p)!=0
 211     except swi.error:
 212         return 0
 213
 214 lexists = exists
 215
 216
 217 def isdir(p):
 218     """
 219   Is a path a directory? Includes image files.
 220   """
 221     try:
 222         return swi.swi('OS_File', '5s;i', p) in [2, 3]
 223     except swi.error:
 224         return 0
 225
 226
 227 def isfile(p):
 228     """
 229   Test whether a path is a file, including image files.
 230   """
 231     try:
 232         return swi.swi('OS_File', '5s;i', p) in [1, 3]
 233     except swi.error:
 234         return 0
 235
 236
 237 def islink(p):
 238     """
 239   RISC OS has no links or mounts.
 240   """
 241     return _false
 242
 243 ismount= islink
 244
 245
 246 # Same-file testing.
 247
 248 # samefile works on filename comparison since there is no ST_DEV and ST_INO is
 249 # not reliably unique (esp. directories). First it has to normalise the
 250 # pathnames, which it can do 'properly' using OS_FSControl since samefile can
 251 # assume it's running on RISC OS (unlike normpath).
 252
 253 def samefile(fa, fb):
 254     """
 255   Test whether two pathnames reference the same actual file.
 256   """
 257     l= 512
 258     b= swi.block(l)
 259     swi.swi('OS_FSControl', 'isb..i', 37, fa, b, l)
 260     fa= b.ctrlstring()
 261     swi.swi('OS_FSControl', 'isb..i', 37, fb, b, l)
 262     fb= b.ctrlstring()
 263     return fa==fb
 264
 265
 266 def sameopenfile(a, b):
 267     """
 268   Test whether two open file objects reference the same file.
 269   """
 270     return os.fstat(a)[stat.ST_INO]==os.fstat(b)[stat.ST_INO]
 271
 272
 273 ## Path canonicalisation
 274
 275 # 'user directory' is taken as meaning the User Root Directory, which is in
 276 # practice never used, for anything.
 277
 278 def expanduser(p):
 279     (fs, drive, path)= _split(p)
 280     l= 512
 281     b= swi.block(l)
 282
 283     if path[:1]!='@':
 284         return p
 285     if fs=='':
 286         fsno= swi.swi('OS_Args', '00;i')
 287         swi.swi('OS_FSControl', 'iibi', 33, fsno, b, l)
 288         fsname= b.ctrlstring()
 289     else:
 290         if fs[:1]=='-':
 291             fsname= fs[1:-1]
 292         else:
 293             fsname= fs[:-1]
 294         fsname= string.split(fsname, '#', 1)[0] # remove special field from fs
 295     x= swi.swi('OS_FSControl', 'ib2s.i;.....i', 54, b, fsname, l)
 296     if x<l:
 297         urd= b.tostring(0, l-x-1)
 298     else: # no URD! try CSD
 299         x= swi.swi('OS_FSControl', 'ib0s.i;.....i', 54, b, fsname, l)
 300         if x<l:
 301             urd= b.tostring(0, l-x-1)
 302         else: # no CSD! use root
 303             urd= '$'
 304     return fsname+':'+urd+path[1:]
 305
 306 # Environment variables are in angle brackets.
 307
 308 def expandvars(p):
 309     """
 310   Expand environment variables using OS_GSTrans.
 311   """
 312     l= 512
 313     b= swi.block(l)
 314     return b.tostring(0, swi.swi('OS_GSTrans', 'sbi;..i', p, b, l))
 315
 316
 317 # Return an absolute path. RISC OS' osfscontrol_canonicalise_path does this among others
 318 abspath = os.expand
 319
 320
 321 # realpath is a no-op on systems without islink support
 322 realpath = abspath
 323
 324
 325 # Normalize a path. Only special path element under RISC OS is "^" for "..".
 326
 327 def normpath(p):
 328     """
 329   Normalize path, eliminating up-directory ^s.
 330   """
 331     (fs, drive, path)= _split(p)
 332     rhs= ''
 333     ups= 0
 334     while path!='':
 335         (path, el)= split(path)
 336         if el=='^':
 337             ups= ups+1
 338         else:
 339             if ups>0:
 340                 ups= ups-1
 341             else:
 342                 if rhs=='':
 343                     rhs= el
 344                 else:
 345                     rhs= el+'.'+rhs
 346     while ups>0:
 347         ups= ups-1
 348         rhs= '^.'+rhs
 349     return fs+drive+rhs
 350
 351
 352 # Directory tree walk.
 353 # Independent of host system. Why am I in os.path?
 354
 355 def walk(top, func, arg):
 356     """Directory tree walk with callback function.
 357
 358     For each directory in the directory tree rooted at top (including top
 359     itself, but excluding '.' and '..'), call func(arg, dirname, fnames).
 360     dirname is the name of the directory, and fnames a list of the names of
 361     the files and subdirectories in dirname (excluding '.' and '..').  func
 362     may modify the fnames list in-place (e.g. via del or slice assignment),
 363     and walk will only recurse into the subdirectories whose names remain in
 364     fnames; this can be used to implement a filter, or to impose a specific
 365     order of visiting.  No semantics are defined for, or required of, arg,
 366     beyond that arg is always passed to func.  It can be used, e.g., to pass
 367     a filename pattern, or a mutable object designed to accumulate
 368     statistics.  Passing None for arg is common."""
 369
 370     try:
 371         names= os.listdir(top)
 372     except os.error:
 373         return
 374     func(arg, top, names)
 375     for name in names:
 376         name= join(top, name)
 377         if isdir(name) and not islink(name):
 378             walk(name, func, arg)