riscospath.py 9.78 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
# Module 'riscospath' -- common operations on RISC OS pathnames.

# contributed by Andrew Clover  ( andrew@oaktree.co.uk )

# The "os.path" name is an alias for this module on RISC OS systems;
# on other systems (e.g. Mac, Windows), os.path provides the same
# operations in a manner specific to that platform, and is an alias
# to another module (e.g. macpath, ntpath).

"""
Instead of importing this module directly, import os and refer to this module
as os.path.
"""


# Imports - make an error-generating swi object if the swi module is not
# available (ie. we are not running on RISC OS Python)

import os, stat, string

try:
Tim Peters's avatar
Tim Peters committed
22
    import swi
23
except ImportError:
Tim Peters's avatar
Tim Peters committed
24 25 26 27 28
    class _swi:
        def swi(*a):
            raise AttributeError, 'This function only available under RISC OS'
        block= swi
    swi= _swi()
29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

[_false, _true]= range(2)

_roots= ['$', '&', '%', '@', '\\']


# _allowMOSFSNames
# After importing riscospath, set _allowMOSFSNames true if you want the module
# to understand the "-SomeFS-" notation left over from the old BBC Master MOS,
# as well as the standard "SomeFS:" notation. Set this to be fully backwards
# compatible but remember that "-SomeFS-" can also be a perfectly valid file
# name so care must be taken when splitting and joining paths.

_allowMOSFSNames= _false


## Path manipulation, RISC OS stylee.

def _split(p):
Tim Peters's avatar
Tim Peters committed
48 49 50
    """
  split filing system name (including special field) and drive specifier from rest
  of path. This is needed by many riscospath functions.
51
  """
Tim Peters's avatar
Tim Peters committed
52 53 54 55 56 57 58 59 60 61 62
    dash= _allowMOSFSNames and p[:1]=='-'
    if dash:
        q= string.find(p, '-', 1)+1
    else:
        if p[:1]==':':
            q= 0
        else:
            q= string.find(p, ':')+1 # q= index of start of non-FS portion of path
    s= string.find(p, '#')
    if s==-1 or s>q:
        s= q # find end of main FS name, not including special field
63
    else:
Tim Peters's avatar
Tim Peters committed
64
        for c in p[dash:s]:
65
            if c not in string.ascii_letters:
Tim Peters's avatar
Tim Peters committed
66 67 68 69 70 71 72 73
                q= 0
                break # disallow invalid non-special-field characters in FS name
    r= q
    if p[q:q+1]==':':
        r= string.find(p, '.', q+1)+1
        if r==0:
            r= len(p) # find end of drive name (if any) following FS name (if any)
    return (p[:q], p[q:r], p[r:])
74 75 76


def normcase(p):
Tim Peters's avatar
Tim Peters committed
77 78 79 80
    """
  Normalize the case of a pathname. This converts to lowercase as the native RISC
  OS filesystems are case-insensitive. However, not all filesystems have to be,
  and there's no simple way to find out what type an FS is argh.
81
  """
Tim Peters's avatar
Tim Peters committed
82
    return string.lower(p)
83 84 85


def isabs(p):
Tim Peters's avatar
Tim Peters committed
86 87 88 89 90 91 92
    """
  Return whether a path is absolute. Under RISC OS, a file system specifier does
  not make a path absolute, but a drive name or number does, and so does using the
  symbol for root, URD, library, CSD or PSD. This means it is perfectly possible
  to have an "absolute" URL dependent on the current working directory, and
  equally you can have a "relative" URL that's on a completely different device to
  the current one argh.
93
  """
Tim Peters's avatar
Tim Peters committed
94 95
    (fs, drive, path)= _split(p)
    return drive!='' or path[:1] in _roots
96 97 98


def join(a, *p):
Tim Peters's avatar
Tim Peters committed
99 100 101
    """
  Join path elements with the directory separator, replacing the entire path when
  an absolute or FS-changing path part is found.
102
  """
Tim Peters's avatar
Tim Peters committed
103 104 105
    j= a
    for b in p:
        (fs, drive, path)= _split(b)
106
        if j=='' or fs!='' or drive!='' or path[:1] in _roots:
Tim Peters's avatar
Tim Peters committed
107
            j= b
108 109
        elif j[-1]==':':
            j= j+b
Tim Peters's avatar
Tim Peters committed
110 111 112
        else:
            j= j+'.'+b
    return j
113 114 115


def split(p):
Tim Peters's avatar
Tim Peters committed
116 117 118
    """
  Split a path in head (everything up to the last '.') and tail (the rest). FS
  name must still be dealt with separately since special field may contain '.'.
119
  """
Tim Peters's avatar
Tim Peters committed
120 121 122 123 124
    (fs, drive, path)= _split(p)
    q= string.rfind(path, '.')
    if q!=-1:
        return (fs+drive+path[:q], path[q+1:])
    return ('', p)
125 126 127


def splitext(p):
Tim Peters's avatar
Tim Peters committed
128 129 130
    """
  Split a path in root and extension. This assumes the 'using slash for dot and
  dot for slash with foreign files' convention common in RISC OS is in force.
131
  """
Tim Peters's avatar
Tim Peters committed
132 133 134 135 136
    (tail, head)= split(p)
    if '/' in head:
        q= len(head)-string.rfind(head, '/')
        return (p[:-q], p[-q:])
    return (p, '')
137 138 139


def splitdrive(p):
Tim Peters's avatar
Tim Peters committed
140 141 142 143
    """
  Split a pathname into a drive specification (including FS name) and the rest of
  the path. The terminating dot of the drive name is included in the drive
  specification.
144
  """
Tim Peters's avatar
Tim Peters committed
145 146
    (fs, drive, path)= _split(p)
    return (fs+drive, p)
147 148 149


def basename(p):
Tim Peters's avatar
Tim Peters committed
150 151
    """
  Return the tail (basename) part of a path.
152
  """
Tim Peters's avatar
Tim Peters committed
153
    return split(p)[1]
154 155 156


def dirname(p):
Tim Peters's avatar
Tim Peters committed
157 158
    """
  Return the head (dirname) part of a path.
159
  """
Tim Peters's avatar
Tim Peters committed
160
    return split(p)[0]
161 162 163


def commonprefix(ps):
Tim Peters's avatar
Tim Peters committed
164 165 166
    """
  Return the longest prefix of all list elements. Purely string-based; does not
  separate any path parts. Why am I in os.path?
167
  """
Tim Peters's avatar
Tim Peters committed
168 169 170 171 172 173 174 175 176 177 178 179
    if len(ps)==0:
        return ''
    prefix= ps[0]
    for p in ps[1:]:
        prefix= prefix[:len(p)]
        for i in range(len(prefix)):
            if prefix[i] <> p[i]:
                prefix= prefix[:i]
                if i==0:
                    return ''
                break
    return prefix
180 181 182 183 184


## File access functions. Why are we in os.path?

def getsize(p):
Tim Peters's avatar
Tim Peters committed
185 186
    """
  Return the size of a file, reported by os.stat().
187
  """
Tim Peters's avatar
Tim Peters committed
188 189
    st= os.stat(p)
    return st[stat.ST_SIZE]
190 191 192


def getmtime(p):
Tim Peters's avatar
Tim Peters committed
193 194
    """
  Return the last modification time of a file, reported by os.stat().
195
  """
Tim Peters's avatar
Tim Peters committed
196 197
    st = os.stat(p)
    return st[stat.ST_MTIME]
198 199 200 201 202 203 204

getatime= getmtime


# RISC OS-specific file access functions

def exists(p):
Tim Peters's avatar
Tim Peters committed
205 206
    """
  Test whether a path exists.
207
  """
Tim Peters's avatar
Tim Peters committed
208 209 210 211
    try:
        return swi.swi('OS_File', '5s;i', p)!=0
    except swi.error:
        return 0
212 213 214


def isdir(p):
Tim Peters's avatar
Tim Peters committed
215 216
    """
  Is a path a directory? Includes image files.
217
  """
Tim Peters's avatar
Tim Peters committed
218 219 220 221
    try:
        return swi.swi('OS_File', '5s;i', p) in [2, 3]
    except swi.error:
        return 0
222 223 224


def isfile(p):
Tim Peters's avatar
Tim Peters committed
225 226
    """
  Test whether a path is a file, including image files.
227
  """
Tim Peters's avatar
Tim Peters committed
228 229 230 231
    try:
        return swi.swi('OS_File', '5s;i', p) in [1, 3]
    except swi.error:
        return 0
232 233 234


def islink(p):
Tim Peters's avatar
Tim Peters committed
235 236
    """
  RISC OS has no links or mounts.
237
  """
Tim Peters's avatar
Tim Peters committed
238
    return _false
239 240 241 242 243 244 245 246 247 248 249 250

ismount= islink


# Same-file testing.

# samefile works on filename comparison since there is no ST_DEV and ST_INO is
# not reliably unique (esp. directories). First it has to normalise the
# pathnames, which it can do 'properly' using OS_FSControl since samefile can
# assume it's running on RISC OS (unlike normpath).

def samefile(fa, fb):
Tim Peters's avatar
Tim Peters committed
251 252
    """
  Test whether two pathnames reference the same actual file.
253
  """
Tim Peters's avatar
Tim Peters committed
254 255 256 257 258 259 260
    l= 512
    b= swi.block(l)
    swi.swi('OS_FSControl', 'isb..i', 37, fa, b, l)
    fa= b.ctrlstring()
    swi.swi('OS_FSControl', 'isb..i', 37, fb, b, l)
    fb= b.ctrlstring()
    return fa==fb
261 262 263


def sameopenfile(a, b):
Tim Peters's avatar
Tim Peters committed
264 265
    """
  Test whether two open file objects reference the same file.
266
  """
Tim Peters's avatar
Tim Peters committed
267
    return os.fstat(a)[stat.ST_INO]==os.fstat(b)[stat.ST_INO]
268 269 270 271 272 273 274 275


## Path canonicalisation

# 'user directory' is taken as meaning the User Root Directory, which is in
# practice never used, for anything.

def expanduser(p):
Tim Peters's avatar
Tim Peters committed
276 277 278 279 280 281 282 283 284 285
    (fs, drive, path)= _split(p)
    l= 512
    b= swi.block(l)

    if path[:1]!='@':
        return p
    if fs=='':
        fsno= swi.swi('OS_Args', '00;i')
        swi.swi('OS_FSControl', 'iibi', 33, fsno, b, l)
        fsname= b.ctrlstring()
286
    else:
Tim Peters's avatar
Tim Peters committed
287 288 289 290 291 292
        if fs[:1]=='-':
            fsname= fs[1:-1]
        else:
            fsname= fs[:-1]
        fsname= string.split(fsname, '#', 1)[0] # remove special field from fs
    x= swi.swi('OS_FSControl', 'ib2s.i;.....i', 54, b, fsname, l)
293
    if x<l:
Tim Peters's avatar
Tim Peters committed
294 295 296 297 298 299 300 301
        urd= b.tostring(0, l-x-1)
    else: # no URD! try CSD
        x= swi.swi('OS_FSControl', 'ib0s.i;.....i', 54, b, fsname, l)
        if x<l:
            urd= b.tostring(0, l-x-1)
        else: # no CSD! use root
            urd= '$'
    return fsname+':'+urd+path[1:]
302 303 304 305

# Environment variables are in angle brackets.

def expandvars(p):
Tim Peters's avatar
Tim Peters committed
306 307
    """
  Expand environment variables using OS_GSTrans.
308
  """
Tim Peters's avatar
Tim Peters committed
309 310 311
    l= 512
    b= swi.block(l)
    return b.tostring(0, swi.swi('OS_GSTrans', 'sbi;..i', p, b, l))
312 313


314 315
# Return an absolute path. RISC OS' osfscontrol_canonicalise_path does this among others
abspath = os.expand
316 317


318 319 320 321
# realpath is a no-op on systems without islink support
realpath = abspath


322 323 324
# Normalize a path. Only special path element under RISC OS is "^" for "..".

def normpath(p):
Tim Peters's avatar
Tim Peters committed
325 326
    """
  Normalize path, eliminating up-directory ^s.
327
  """
Tim Peters's avatar
Tim Peters committed
328 329 330 331 332 333 334
    (fs, drive, path)= _split(p)
    rhs= ''
    ups= 0
    while path!='':
        (path, el)= split(path)
        if el=='^':
            ups= ups+1
335
        else:
Tim Peters's avatar
Tim Peters committed
336 337 338 339 340 341 342 343 344 345 346
            if ups>0:
                ups= ups-1
            else:
                if rhs=='':
                    rhs= el
                else:
                    rhs= el+'.'+rhs
    while ups>0:
        ups= ups-1
        rhs= '^.'+rhs
    return fs+drive+rhs
347 348 349 350 351 352


# Directory tree walk.
# Independent of host system. Why am I in os.path?

def walk(top, func, arg):
353 354 355 356 357 358 359 360 361 362 363 364 365 366
    """Directory tree walk with callback function.

    For each directory in the directory tree rooted at top (including top
    itself, but excluding '.' and '..'), call func(arg, dirname, fnames).
    dirname is the name of the directory, and fnames a list of the names of
    the files and subdirectories in dirname (excluding '.' and '..').  func
    may modify the fnames list in-place (e.g. via del or slice assignment),
    and walk will only recurse into the subdirectories whose names remain in
    fnames; this can be used to implement a filter, or to impose a specific
    order of visiting.  No semantics are defined for, or required of, arg,
    beyond that arg is always passed to func.  It can be used, e.g., to pass
    a filename pattern, or a mutable object designed to accumulate
    statistics.  Passing None for arg is common."""

Tim Peters's avatar
Tim Peters committed
367 368 369 370 371 372 373 374 375
    try:
        names= os.listdir(top)
    except os.error:
        return
    func(arg, top, names)
    for name in names:
        name= join(top, name)
        if isdir(name) and not islink(name):
            walk(name, func, arg)