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(ps):
 172     """
 173   Return the longest prefix of all list elements. Purely string-based; does not
 174   separate any path parts. Why am I in os.path?
 175   """
 176     if len(ps)==0:
 177         return ''
 178     prefix= ps[0]
 179     for p in ps[1:]:
 180         prefix= prefix[:len(p)]
 181         for i in range(len(prefix)):
 182             if prefix[i] <> p[i]:
 183                 prefix= prefix[:i]
 184                 if i==0:
 185                     return ''
 186                 break
 187     return prefix
 188
 189
 190 ## File access functions. Why are we in os.path?
 191
 192 def getsize(p):
 193     """
 194   Return the size of a file, reported by os.stat().
 195   """
 196     st= os.stat(p)
 197     return st[stat.ST_SIZE]
 198
 199
 200 def getmtime(p):
 201     """
 202   Return the last modification time of a file, reported by os.stat().
 203   """
 204     st = os.stat(p)
 205     return st[stat.ST_MTIME]
 206
 207 getatime= getmtime
 208
 209
 210 # RISC OS-specific file access functions
 211
 212 def exists(p):
 213     """
 214   Test whether a path exists.
 215   """
 216     try:
 217         return swi.swi('OS_File', '5s;i', p)!=0
 218     except swi.error:
 219         return 0
 220
 221
 222 def isdir(p):
 223     """
 224   Is a path a directory? Includes image files.
 225   """
 226     try:
 227         return swi.swi('OS_File', '5s;i', p) in [2, 3]
 228     except swi.error:
 229         return 0
 230
 231
 232 def isfile(p):
 233     """
 234   Test whether a path is a file, including image files.
 235   """
 236     try:
 237         return swi.swi('OS_File', '5s;i', p) in [1, 3]
 238     except swi.error:
 239         return 0
 240
 241
 242 def islink(p):
 243     """
 244   RISC OS has no links or mounts.
 245   """
 246     return _false
 247
 248 ismount= islink
 249
 250
 251 # Same-file testing.
 252
 253 # samefile works on filename comparison since there is no ST_DEV and ST_INO is
 254 # not reliably unique (esp. directories). First it has to normalise the
 255 # pathnames, which it can do 'properly' using OS_FSControl since samefile can
 256 # assume it's running on RISC OS (unlike normpath).
 257
 258 def samefile(fa, fb):
 259     """
 260   Test whether two pathnames reference the same actual file.
 261   """
 262     l= 512
 263     b= swi.block(l)
 264     swi.swi('OS_FSControl', 'isb..i', 37, fa, b, l)
 265     fa= b.ctrlstring()
 266     swi.swi('OS_FSControl', 'isb..i', 37, fb, b, l)
 267     fb= b.ctrlstring()
 268     return fa==fb
 269
 270
 271 def sameopenfile(a, b):
 272     """
 273   Test whether two open file objects reference the same file.
 274   """
 275     return os.fstat(a)[stat.ST_INO]==os.fstat(b)[stat.ST_INO]
 276
 277
 278 ## Path canonicalisation
 279
 280 # 'user directory' is taken as meaning the User Root Directory, which is in
 281 # practice never used, for anything.
 282
 283 def expanduser(p):
 284     (fs, drive, path)= _split(p)
 285     l= 512
 286     b= swi.block(l)
 287
 288     if path[:1]!='@':
 289         return p
 290     if fs=='':
 291         fsno= swi.swi('OS_Args', '00;i')
 292         swi.swi('OS_FSControl', 'iibi', 33, fsno, b, l)
 293         fsname= b.ctrlstring()
 294     else:
 295         if fs[:1]=='-':
 296             fsname= fs[1:-1]
 297         else:
 298             fsname= fs[:-1]
 299         fsname= string.split(fsname, '#', 1)[0] # remove special field from fs
 300     x= swi.swi('OS_FSControl', 'ib2s.i;.....i', 54, b, fsname, l)
 301     if x<l:
 302         urd= b.tostring(0, l-x-1)
 303     else: # no URD! try CSD
 304         x= swi.swi('OS_FSControl', 'ib0s.i;.....i', 54, b, fsname, l)
 305         if x<l:
 306             urd= b.tostring(0, l-x-1)
 307         else: # no CSD! use root
 308             urd= '$'
 309     return fsname+':'+urd+path[1:]
 310
 311 # Environment variables are in angle brackets.
 312
 313 def expandvars(p):
 314     """
 315   Expand environment variables using OS_GSTrans.
 316   """
 317     l= 512
 318     b= swi.block(l)
 319     return b.tostring(0, swi.swi('OS_GSTrans', 'sbi;..i', p, b, l))
 320
 321
 322 # Return an absolute path. RISC OS' osfscontrol_canonicalise_path does this among others
 323 abspath = os.expand
 324
 325
 326 # realpath is a no-op on systems without islink support
 327 realpath = abspath
 328
 329
 330 # Normalize a path. Only special path element under RISC OS is "^" for "..".
 331
 332 def normpath(p):
 333     """
 334   Normalize path, eliminating up-directory ^s.
 335   """
 336     (fs, drive, path)= _split(p)
 337     rhs= ''
 338     ups= 0
 339     while path!='':
 340         (path, el)= split(path)
 341         if el=='^':
 342             ups= ups+1
 343         else:
 344             if ups>0:
 345                 ups= ups-1
 346             else:
 347                 if rhs=='':
 348                     rhs= el
 349                 else:
 350                     rhs= el+'.'+rhs
 351     while ups>0:
 352         ups= ups-1
 353         rhs= '^.'+rhs
 354     return fs+drive+rhs
 355
 356
 357 # Directory tree walk.
 358 # Independent of host system. Why am I in os.path?
 359
 360 def walk(top, func, arg):
 361     """Directory tree walk with callback function.
 362
 363     For each directory in the directory tree rooted at top (including top
 364     itself, but excluding '.' and '..'), call func(arg, dirname, fnames).
 365     dirname is the name of the directory, and fnames a list of the names of
 366     the files and subdirectories in dirname (excluding '.' and '..').  func
 367     may modify the fnames list in-place (e.g. via del or slice assignment),
 368     and walk will only recurse into the subdirectories whose names remain in
 369     fnames; this can be used to implement a filter, or to impose a specific
 370     order of visiting.  No semantics are defined for, or required of, arg,
 371     beyond that arg is always passed to func.  It can be used, e.g., to pass
 372     a filename pattern, or a mutable object designed to accumulate
 373     statistics.  Passing None for arg is common."""
 374
 375     try:
 376         names= os.listdir(top)
 377     except os.error:
 378         return
 379     func(arg, top, names)
 380     for name in names:
 381         name= join(top, name)
 382         if isdir(name) and not islink(name):
 383             walk(name, func, arg)