ref: 0e6e44b06400e320145eb5115edce054cfd26d1f
dir: /sys/lib/python/plat-riscos/riscospath.py/
# 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.
"""
# strings representing various path-related bits and pieces
curdir = '@'
pardir = '^'
extsep = '/'
sep = '.'
pathsep = ','
defpath = '<Run$Dir>'
altsep = None
# 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:
import swi
except ImportError:
class _swi:
def swi(*a):
raise AttributeError, 'This function only available under RISC OS'
block= swi
swi= _swi()
[_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):
"""
split filing system name (including special field) and drive specifier from rest
of path. This is needed by many riscospath functions.
"""
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
else:
for c in p[dash:s]:
if c not in string.ascii_letters:
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:])
def normcase(p):
"""
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.
"""
return string.lower(p)
def isabs(p):
"""
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.
"""
(fs, drive, path)= _split(p)
return drive!='' or path[:1] in _roots
def join(a, *p):
"""
Join path elements with the directory separator, replacing the entire path when
an absolute or FS-changing path part is found.
"""
j= a
for b in p:
(fs, drive, path)= _split(b)
if j=='' or fs!='' or drive!='' or path[:1] in _roots:
j= b
elif j[-1]==':':
j= j+b
else:
j= j+'.'+b
return j
def split(p):
"""
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 '.'.
"""
(fs, drive, path)= _split(p)
q= string.rfind(path, '.')
if q!=-1:
return (fs+drive+path[:q], path[q+1:])
return ('', p)
def splitext(p):
"""
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.
"""
(tail, head)= split(p)
if '/' in head:
q= len(head)-string.rfind(head, '/')
return (p[:-q], p[-q:])
return (p, '')
def splitdrive(p):
"""
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.
"""
(fs, drive, path)= _split(p)
return (fs+drive, p)
def basename(p):
"""
Return the tail (basename) part of a path.
"""
return split(p)[1]
def dirname(p):
"""
Return the head (dirname) part of a path.
"""
return split(p)[0]
def commonprefix(m):
"Given a list of pathnames, returns the longest common leading component"
if not m: return ''
s1 = min(m)
s2 = max(m)
n = min(len(s1), len(s2))
for i in xrange(n):
if s1[i] != s2[i]:
return s1[:i]
return s1[:n]
## File access functions. Why are we in os.path?
def getsize(p):
"""
Return the size of a file, reported by os.stat().
"""
st= os.stat(p)
return st[stat.ST_SIZE]
def getmtime(p):
"""
Return the last modification time of a file, reported by os.stat().
"""
st = os.stat(p)
return st[stat.ST_MTIME]
getatime= getmtime
# RISC OS-specific file access functions
def exists(p):
"""
Test whether a path exists.
"""
try:
return swi.swi('OS_File', '5s;i', p)!=0
except swi.error:
return 0
lexists = exists
def isdir(p):
"""
Is a path a directory? Includes image files.
"""
try:
return swi.swi('OS_File', '5s;i', p) in [2, 3]
except swi.error:
return 0
def isfile(p):
"""
Test whether a path is a file, including image files.
"""
try:
return swi.swi('OS_File', '5s;i', p) in [1, 3]
except swi.error:
return 0
def islink(p):
"""
RISC OS has no links or mounts.
"""
return _false
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):
"""
Test whether two pathnames reference the same actual file.
"""
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
def sameopenfile(a, b):
"""
Test whether two open file objects reference the same file.
"""
return os.fstat(a)[stat.ST_INO]==os.fstat(b)[stat.ST_INO]
## Path canonicalisation
# 'user directory' is taken as meaning the User Root Directory, which is in
# practice never used, for anything.
def expanduser(p):
(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()
else:
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)
if x<l:
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:]
# Environment variables are in angle brackets.
def expandvars(p):
"""
Expand environment variables using OS_GSTrans.
"""
l= 512
b= swi.block(l)
return b.tostring(0, swi.swi('OS_GSTrans', 'sbi;..i', p, b, l))
# Return an absolute path. RISC OS' osfscontrol_canonicalise_path does this among others
abspath = os.expand
# realpath is a no-op on systems without islink support
realpath = abspath
# Normalize a path. Only special path element under RISC OS is "^" for "..".
def normpath(p):
"""
Normalize path, eliminating up-directory ^s.
"""
(fs, drive, path)= _split(p)
rhs= ''
ups= 0
while path!='':
(path, el)= split(path)
if el=='^':
ups= ups+1
else:
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
# Directory tree walk.
# Independent of host system. Why am I in os.path?
def walk(top, func, arg):
"""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."""
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)