blob: 7972aa92c0c3f6f5fa97d53a817d487ed9e21738 [file] [log] [blame]
Guido van Rossum15e22e11997-12-05 19:03:01 +00001# Module 'ntpath' -- common operations on WinNT/Win95 pathnames
Tim Peters2344fae2001-01-15 00:50:52 +00002"""Common pathname manipulations, WindowsNT/95 version.
Guido van Rossum534972b1999-02-03 17:20:50 +00003
4Instead of importing this module directly, import os and refer to this
5module as os.path.
Guido van Rossum15e22e11997-12-05 19:03:01 +00006"""
Guido van Rossum555915a1994-02-24 11:32:59 +00007
8import os
Mark Hammond8696ebc2002-10-08 02:44:31 +00009import sys
Christian Heimes05e8be12008-02-23 18:30:17 +000010import stat
Guido van Rossumd8faa362007-04-27 19:54:29 +000011import genericpath
Thomas Wouters89f507f2006-12-13 04:49:30 +000012from genericpath import *
Skip Montanaro4d5d5bf2000-07-13 01:01:03 +000013
Skip Montanaro269b83b2001-02-06 01:07:02 +000014__all__ = ["normcase","isabs","join","splitdrive","split","splitext",
15 "basename","dirname","commonprefix","getsize","getmtime",
Georg Brandlf0de6a12005-08-22 18:02:59 +000016 "getatime","getctime", "islink","exists","lexists","isdir","isfile",
Benjamin Petersond71ca412008-05-08 23:44:58 +000017 "ismount", "expanduser","expandvars","normpath","abspath",
Georg Brandlf0de6a12005-08-22 18:02:59 +000018 "splitunc","curdir","pardir","sep","pathsep","defpath","altsep",
Guido van Rossumd8faa362007-04-27 19:54:29 +000019 "extsep","devnull","realpath","supports_unicode_filenames","relpath"]
Guido van Rossum555915a1994-02-24 11:32:59 +000020
Skip Montanaro117910d2003-02-14 19:35:31 +000021# strings representing various path-related bits and pieces
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +000022# These are primarily for export; internally, they are hardcoded.
Skip Montanaro117910d2003-02-14 19:35:31 +000023curdir = '.'
24pardir = '..'
25extsep = '.'
26sep = '\\'
27pathsep = ';'
Skip Montanaro9ddac3e2003-03-28 22:23:24 +000028altsep = '/'
Andrew MacIntyre437966c2003-02-17 09:17:50 +000029defpath = '.;C:\\bin'
Skip Montanaro117910d2003-02-14 19:35:31 +000030if 'ce' in sys.builtin_module_names:
31 defpath = '\\Windows'
32elif 'os2' in sys.builtin_module_names:
Andrew MacIntyre437966c2003-02-17 09:17:50 +000033 # OS/2 w/ VACPP
Skip Montanaro117910d2003-02-14 19:35:31 +000034 altsep = '/'
Martin v. Löwisbdec50f2004-06-08 08:29:33 +000035devnull = 'nul'
Skip Montanaro117910d2003-02-14 19:35:31 +000036
Mark Hammond5a607a32009-05-06 08:04:54 +000037def _get_empty(path):
38 if isinstance(path, bytes):
39 return b''
40 else:
41 return ''
42
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +000043def _get_sep(path):
44 if isinstance(path, bytes):
45 return b'\\'
46 else:
47 return '\\'
48
49def _get_altsep(path):
50 if isinstance(path, bytes):
51 return b'/'
52 else:
53 return '/'
54
55def _get_bothseps(path):
56 if isinstance(path, bytes):
57 return b'\\/'
58 else:
59 return '\\/'
60
61def _get_dot(path):
62 if isinstance(path, bytes):
63 return b'.'
64 else:
65 return '.'
66
67def _get_colon(path):
68 if isinstance(path, bytes):
69 return b':'
70 else:
71 return ':'
72
Guido van Rossume2ad88c1997-08-12 14:46:58 +000073# Normalize the case of a pathname and map slashes to backslashes.
74# Other normalizations (such as optimizing '../' away) are not done
Guido van Rossum555915a1994-02-24 11:32:59 +000075# (this is done by normpath).
Guido van Rossume2ad88c1997-08-12 14:46:58 +000076
Guido van Rossum555915a1994-02-24 11:32:59 +000077def normcase(s):
Guido van Rossum16a0bc21998-02-18 13:48:31 +000078 """Normalize case of pathname.
79
Guido van Rossum534972b1999-02-03 17:20:50 +000080 Makes all characters lowercase and all slashes into backslashes."""
Ezio Melotti5a3ef5b2010-06-25 10:56:11 +000081 if not isinstance(s, (bytes, str)):
82 raise TypeError("normcase() argument must be str or bytes, "
83 "not '{}'".format(s.__class__.__name__))
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +000084 return s.replace(_get_altsep(s), _get_sep(s)).lower()
Guido van Rossum555915a1994-02-24 11:32:59 +000085
Guido van Rossum77e1db31997-06-02 23:11:57 +000086
Fred Drakeef0b5dd2000-02-17 17:30:40 +000087# Return whether a path is absolute.
Mark Hammond5a607a32009-05-06 08:04:54 +000088# Trivial in Posix, harder on Windows.
89# For Windows it is absolute if it starts with a slash or backslash (current
90# volume), or if a pathname after the volume-letter-and-colon or UNC-resource
Guido van Rossum534972b1999-02-03 17:20:50 +000091# starts with a slash or backslash.
Guido van Rossum555915a1994-02-24 11:32:59 +000092
93def isabs(s):
Guido van Rossum15e22e11997-12-05 19:03:01 +000094 """Test whether a path is absolute"""
95 s = splitdrive(s)[1]
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +000096 return len(s) > 0 and s[:1] in _get_bothseps(s)
Guido van Rossum555915a1994-02-24 11:32:59 +000097
98
Guido van Rossum77e1db31997-06-02 23:11:57 +000099# Join two (or more) paths.
100
Barry Warsaw384d2491997-02-18 21:53:25 +0000101def join(a, *p):
Guido van Rossum04110fb2007-08-24 16:32:05 +0000102 """Join two or more pathname components, inserting "\\" as needed.
103 If any component is an absolute path, all previous path components
104 will be discarded."""
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000105 sep = _get_sep(a)
106 seps = _get_bothseps(a)
107 colon = _get_colon(a)
Guido van Rossum15e22e11997-12-05 19:03:01 +0000108 path = a
109 for b in p:
Tim Peters33dc0a12001-07-27 08:09:54 +0000110 b_wins = 0 # set to 1 iff b makes path irrelevant
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000111 if not path:
Tim Peters33dc0a12001-07-27 08:09:54 +0000112 b_wins = 1
Tim Peters1bdd0f22001-07-19 17:18:18 +0000113
Tim Peters33dc0a12001-07-27 08:09:54 +0000114 elif isabs(b):
115 # This probably wipes out path so far. However, it's more
Mark Hammond5a607a32009-05-06 08:04:54 +0000116 # complicated if path begins with a drive letter. You get a+b
117 # (minus redundant slashes) in these four cases:
Tim Peters33dc0a12001-07-27 08:09:54 +0000118 # 1. join('c:', '/a') == 'c:/a'
Mark Hammond5a607a32009-05-06 08:04:54 +0000119 # 2. join('//computer/share', '/a') == '//computer/share/a'
120 # 3. join('c:/', '/a') == 'c:/a'
121 # 4. join('//computer/share/', '/a') == '//computer/share/a'
122 # But b wins in all of these cases:
123 # 5. join('c:/a', '/b') == '/b'
124 # 6. join('//computer/share/a', '/b') == '/b'
125 # 7. join('c:', 'd:/') == 'd:/'
126 # 8. join('c:', '//computer/share/') == '//computer/share/'
127 # 9. join('//computer/share', 'd:/') == 'd:/'
128 # 10. join('//computer/share', '//computer/share/') == '//computer/share/'
129 # 11. join('c:/', 'd:/') == 'd:/'
130 # 12. join('c:/', '//computer/share/') == '//computer/share/'
131 # 13. join('//computer/share/', 'd:/') == 'd:/'
132 # 14. join('//computer/share/', '//computer/share/') == '//computer/share/'
133 b_prefix, b_rest = splitdrive(b)
Tim Peters1bdd0f22001-07-19 17:18:18 +0000134
Mark Hammond5a607a32009-05-06 08:04:54 +0000135 # if b has a prefix, it always wins.
136 if b_prefix:
Tim Peters33dc0a12001-07-27 08:09:54 +0000137 b_wins = 1
Mark Hammond5a607a32009-05-06 08:04:54 +0000138 else:
139 # b doesn't have a prefix.
140 # but isabs(b) returned true.
141 # and therefore b_rest[0] must be a slash.
142 # (but let's check that.)
143 assert(b_rest and b_rest[0] in seps)
144
145 # so, b still wins if path has a rest that's more than a sep.
146 # you get a+b if path_rest is empty or only has a sep.
147 # (see cases 1-4 for times when b loses.)
148 path_rest = splitdrive(path)[1]
149 b_wins = path_rest and path_rest not in seps
Tim Peters1bdd0f22001-07-19 17:18:18 +0000150
Tim Peters33dc0a12001-07-27 08:09:54 +0000151 if b_wins:
152 path = b
153 else:
154 # Join, and ensure there's a separator.
155 assert len(path) > 0
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000156 if path[-1:] in seps:
157 if b and b[:1] in seps:
Tim Peters33dc0a12001-07-27 08:09:54 +0000158 path += b[1:]
159 else:
160 path += b
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000161 elif path[-1:] == colon:
Tim Peters33dc0a12001-07-27 08:09:54 +0000162 path += b
163 elif b:
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000164 if b[:1] in seps:
Tim Peters33dc0a12001-07-27 08:09:54 +0000165 path += b
166 else:
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000167 path += sep + b
Tim Peters6a3e5f12001-11-05 21:25:02 +0000168 else:
169 # path is not empty and does not end with a backslash,
170 # but b is empty; since, e.g., split('a/') produces
171 # ('a', ''), it's best if join() adds a backslash in
172 # this case.
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000173 path += sep
Tim Peters1bdd0f22001-07-19 17:18:18 +0000174
Guido van Rossum15e22e11997-12-05 19:03:01 +0000175 return path
Guido van Rossum555915a1994-02-24 11:32:59 +0000176
177
178# Split a path in a drive specification (a drive letter followed by a
Guido van Rossumf3c695c1999-04-06 19:32:19 +0000179# colon) and the path specification.
Guido van Rossum555915a1994-02-24 11:32:59 +0000180# It is always true that drivespec + pathspec == p
181def splitdrive(p):
Mark Hammond5a607a32009-05-06 08:04:54 +0000182 """Split a pathname into drive/UNC sharepoint and relative path specifiers.
183 Returns a 2-tuple (drive_or_unc, path); either part may be empty.
184
185 If you assign
186 result = splitdrive(p)
187 It is always true that:
188 result[0] + result[1] == p
189
190 If the path contained a drive letter, drive_or_unc will contain everything
191 up to and including the colon. e.g. splitdrive("c:/dir") returns ("c:", "/dir")
192
193 If the path contained a UNC path, the drive_or_unc will contain the host name
194 and share up to but not including the fourth directory separator character.
195 e.g. splitdrive("//host/computer/dir") returns ("//host/computer", "/dir")
196
197 Paths cannot contain both a drive letter and a UNC path.
198
199 """
200 empty = _get_empty(p)
201 if len(p) > 1:
202 sep = _get_sep(p)
203 normp = normcase(p)
204 if (normp[0:2] == sep*2) and (normp[2:3] != sep):
205 # is a UNC path:
206 # vvvvvvvvvvvvvvvvvvvv drive letter or UNC path
207 # \\machine\mountpoint\directory\etc\...
208 # directory ^^^^^^^^^^^^^^^
209 index = normp.find(sep, 2)
210 if index == -1:
211 return empty, p
212 index2 = normp.find(sep, index + 1)
213 # a UNC path can't have two slashes in a row
214 # (after the initial two)
215 if index2 == index + 1:
216 return empty, p
217 if index2 == -1:
218 index2 = len(p)
219 return p[:index2], p[index2:]
220 if normp[1:2] == _get_colon(p):
221 return p[:2], p[2:]
222 return empty, p
Guido van Rossumf3c695c1999-04-06 19:32:19 +0000223
224
225# Parse UNC paths
226def splitunc(p):
Mark Hammond5a607a32009-05-06 08:04:54 +0000227 """Deprecated since Python 3.1. Please use splitdrive() instead;
228 it now handles UNC paths.
229
230 Split a pathname into UNC mount point and relative path specifiers.
Guido van Rossumf3c695c1999-04-06 19:32:19 +0000231
232 Return a 2-tuple (unc, rest); either part may be empty.
233 If unc is not empty, it has the form '//host/mount' (or similar
234 using backslashes). unc+rest is always the input path.
235 Paths containing drive letters never have an UNC part.
236 """
Mark Hammond5a607a32009-05-06 08:04:54 +0000237 import warnings
238 warnings.warn("ntpath.splitunc is deprecated, use ntpath.splitdrive instead",
Gregory P. Smithaa3b5b82009-06-30 05:33:50 +0000239 DeprecationWarning)
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000240 sep = _get_sep(p)
241 if not p[1:2]:
242 return p[:0], p # Drive letter present
Guido van Rossum534972b1999-02-03 17:20:50 +0000243 firstTwo = p[0:2]
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000244 if normcase(firstTwo) == sep + sep:
Guido van Rossum534972b1999-02-03 17:20:50 +0000245 # is a UNC path:
246 # vvvvvvvvvvvvvvvvvvvv equivalent to drive letter
247 # \\machine\mountpoint\directories...
248 # directory ^^^^^^^^^^^^^^^
249 normp = normcase(p)
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000250 index = normp.find(sep, 2)
Guido van Rossum534972b1999-02-03 17:20:50 +0000251 if index == -1:
252 ##raise RuntimeError, 'illegal UNC path: "' + p + '"'
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000253 return (p[:0], p)
254 index = normp.find(sep, index + 1)
Guido van Rossum534972b1999-02-03 17:20:50 +0000255 if index == -1:
256 index = len(p)
257 return p[:index], p[index:]
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000258 return p[:0], p
Guido van Rossum555915a1994-02-24 11:32:59 +0000259
260
261# Split a path in head (everything up to the last '/') and tail (the
Guido van Rossum8f0fa9e1999-03-19 21:05:12 +0000262# rest). After the trailing '/' is stripped, the invariant
Guido van Rossum555915a1994-02-24 11:32:59 +0000263# join(head, tail) == p holds.
264# The resulting head won't end in '/' unless it is the root.
265
266def split(p):
Guido van Rossum534972b1999-02-03 17:20:50 +0000267 """Split a pathname.
268
269 Return tuple (head, tail) where tail is everything after the final slash.
270 Either part may be empty."""
Guido van Rossum8f0fa9e1999-03-19 21:05:12 +0000271
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000272 seps = _get_bothseps(p)
Guido van Rossum15e22e11997-12-05 19:03:01 +0000273 d, p = splitdrive(p)
Guido van Rossum8f0fa9e1999-03-19 21:05:12 +0000274 # set i to index beyond p's last slash
275 i = len(p)
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000276 while i and p[i-1] not in seps:
Guido van Rossum8f0fa9e1999-03-19 21:05:12 +0000277 i = i - 1
278 head, tail = p[:i], p[i:] # now tail has no slashes
279 # remove trailing slashes from head, unless it's all slashes
280 head2 = head
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000281 while head2 and head2[-1:] in seps:
Guido van Rossum8f0fa9e1999-03-19 21:05:12 +0000282 head2 = head2[:-1]
283 head = head2 or head
Guido van Rossum15e22e11997-12-05 19:03:01 +0000284 return d + head, tail
Guido van Rossum555915a1994-02-24 11:32:59 +0000285
286
287# Split a path in root and extension.
Guido van Rossum73e122f1997-01-22 00:17:26 +0000288# The extension is everything starting at the last dot in the last
Guido van Rossum555915a1994-02-24 11:32:59 +0000289# pathname component; the root is everything before that.
290# It is always true that root + ext == p.
291
292def splitext(p):
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000293 return genericpath._splitext(p, _get_sep(p), _get_altsep(p),
294 _get_dot(p))
Guido van Rossumd8faa362007-04-27 19:54:29 +0000295splitext.__doc__ = genericpath._splitext.__doc__
Guido van Rossum555915a1994-02-24 11:32:59 +0000296
297
298# Return the tail (basename) part of a path.
299
300def basename(p):
Guido van Rossum15e22e11997-12-05 19:03:01 +0000301 """Returns the final component of a pathname"""
302 return split(p)[1]
Guido van Rossum555915a1994-02-24 11:32:59 +0000303
304
305# Return the head (dirname) part of a path.
306
307def dirname(p):
Guido van Rossum15e22e11997-12-05 19:03:01 +0000308 """Returns the directory component of a pathname"""
309 return split(p)[0]
Guido van Rossum555915a1994-02-24 11:32:59 +0000310
Guido van Rossum555915a1994-02-24 11:32:59 +0000311# Is a path a symbolic link?
312# This will always return false on systems where posix.lstat doesn't exist.
313
314def islink(path):
Thomas Wouters89f507f2006-12-13 04:49:30 +0000315 """Test for symbolic link.
316 On WindowsNT/95 and OS/2 always returns false
317 """
Guido van Rossum8ca162f2002-04-07 06:36:23 +0000318 return False
Guido van Rossum555915a1994-02-24 11:32:59 +0000319
Thomas Wouters89f507f2006-12-13 04:49:30 +0000320# alias exists to lexists
Johannes Gijsbersae882f72004-08-30 10:19:56 +0000321lexists = exists
322
Guido van Rossumf3c695c1999-04-06 19:32:19 +0000323# Is a path a mount point? Either a root (with or without drive letter)
324# or an UNC path with at most a / or \ after the mount point.
Guido van Rossum555915a1994-02-24 11:32:59 +0000325
326def ismount(path):
Guido van Rossumca99c2c1998-01-19 22:25:59 +0000327 """Test whether a path is a mount point (defined as root of drive)"""
Benjamin Peterson48e24782009-03-29 13:02:52 +0000328 seps = _get_bothseps(path)
Mark Hammond5a607a32009-05-06 08:04:54 +0000329 root, rest = splitdrive(path)
330 if root and root[0] in seps:
331 return (not rest) or (rest in seps)
332 return rest in seps
Guido van Rossum555915a1994-02-24 11:32:59 +0000333
334
Guido van Rossum555915a1994-02-24 11:32:59 +0000335# Expand paths beginning with '~' or '~user'.
336# '~' means $HOME; '~user' means that user's home directory.
337# If the path doesn't begin with '~', or if the user or $HOME is unknown,
338# the path is returned unchanged (leaving error reporting to whatever
339# function is called with the expanded path as argument).
340# See also module 'glob' for expansion of *, ? and [...] in pathnames.
341# (A function should also be defined to do full *sh-style environment
342# variable expansion.)
343
344def expanduser(path):
Guido van Rossum534972b1999-02-03 17:20:50 +0000345 """Expand ~ and ~user constructs.
346
347 If user or $HOME is unknown, do nothing."""
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000348 if isinstance(path, bytes):
349 tilde = b'~'
350 else:
351 tilde = '~'
352 if not path.startswith(tilde):
Guido van Rossum15e22e11997-12-05 19:03:01 +0000353 return path
354 i, n = 1, len(path)
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000355 while i < n and path[i] not in _get_bothseps(path):
Fred Drakeb4e460a2000-09-28 16:25:20 +0000356 i = i + 1
Guido van Rossumd8faa362007-04-27 19:54:29 +0000357
358 if 'HOME' in os.environ:
359 userhome = os.environ['HOME']
360 elif 'USERPROFILE' in os.environ:
361 userhome = os.environ['USERPROFILE']
362 elif not 'HOMEPATH' in os.environ:
Guido van Rossum15e22e11997-12-05 19:03:01 +0000363 return path
Guido van Rossumd8faa362007-04-27 19:54:29 +0000364 else:
365 try:
366 drive = os.environ['HOMEDRIVE']
367 except KeyError:
368 drive = ''
369 userhome = join(drive, os.environ['HOMEPATH'])
370
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000371 if isinstance(path, bytes):
372 userhome = userhome.encode(sys.getfilesystemencoding())
373
Guido van Rossumd8faa362007-04-27 19:54:29 +0000374 if i != 1: #~user
375 userhome = join(dirname(userhome), path[1:i])
376
Guido van Rossum15e22e11997-12-05 19:03:01 +0000377 return userhome + path[i:]
Guido van Rossum555915a1994-02-24 11:32:59 +0000378
379
380# Expand paths containing shell variable substitutions.
381# The following rules apply:
Guido van Rossum15e22e11997-12-05 19:03:01 +0000382# - no expansion within single quotes
Guido van Rossumd8faa362007-04-27 19:54:29 +0000383# - '$$' is translated into '$'
384# - '%%' is translated into '%' if '%%' are not seen in %var1%%var2%
Guido van Rossum15e22e11997-12-05 19:03:01 +0000385# - ${varname} is accepted.
Guido van Rossumd8faa362007-04-27 19:54:29 +0000386# - $varname is accepted.
387# - %varname% is accepted.
388# - varnames can be made out of letters, digits and the characters '_-'
389# (though is not verifed in the ${varname} and %varname% cases)
Guido van Rossum555915a1994-02-24 11:32:59 +0000390# XXX With COMMAND.COM you can use any characters in a variable name,
391# XXX except '^|<>='.
392
Tim Peters2344fae2001-01-15 00:50:52 +0000393def expandvars(path):
Guido van Rossumd8faa362007-04-27 19:54:29 +0000394 """Expand shell variables of the forms $var, ${var} and %var%.
Guido van Rossum534972b1999-02-03 17:20:50 +0000395
396 Unknown variables are left unchanged."""
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000397 if isinstance(path, bytes):
398 if ord('$') not in path and ord('%') not in path:
399 return path
400 import string
401 varchars = bytes(string.ascii_letters + string.digits + '_-', 'ascii')
Amaury Forgeot d'Arc3b44e612008-10-03 20:32:33 +0000402 quote = b'\''
403 percent = b'%'
404 brace = b'{'
405 dollar = b'$'
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000406 else:
407 if '$' not in path and '%' not in path:
408 return path
409 import string
410 varchars = string.ascii_letters + string.digits + '_-'
Amaury Forgeot d'Arc3b44e612008-10-03 20:32:33 +0000411 quote = '\''
412 percent = '%'
413 brace = '{'
414 dollar = '$'
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000415 res = path[:0]
Guido van Rossum15e22e11997-12-05 19:03:01 +0000416 index = 0
417 pathlen = len(path)
418 while index < pathlen:
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000419 c = path[index:index+1]
Amaury Forgeot d'Arc3b44e612008-10-03 20:32:33 +0000420 if c == quote: # no expansion within single quotes
Guido van Rossum15e22e11997-12-05 19:03:01 +0000421 path = path[index + 1:]
422 pathlen = len(path)
423 try:
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000424 index = path.index(c)
425 res = res + c + path[:index + 1]
Fred Drakeb4e460a2000-09-28 16:25:20 +0000426 except ValueError:
Guido van Rossum15e22e11997-12-05 19:03:01 +0000427 res = res + path
Fred Drakeb4e460a2000-09-28 16:25:20 +0000428 index = pathlen - 1
Amaury Forgeot d'Arc3b44e612008-10-03 20:32:33 +0000429 elif c == percent: # variable or '%'
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000430 if path[index + 1:index + 2] == percent:
Guido van Rossumd8faa362007-04-27 19:54:29 +0000431 res = res + c
432 index = index + 1
433 else:
434 path = path[index+1:]
435 pathlen = len(path)
436 try:
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000437 index = path.index(percent)
Guido van Rossumd8faa362007-04-27 19:54:29 +0000438 except ValueError:
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000439 res = res + percent + path
Guido van Rossumd8faa362007-04-27 19:54:29 +0000440 index = pathlen - 1
441 else:
442 var = path[:index]
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000443 if isinstance(path, bytes):
444 var = var.decode('ascii')
Guido van Rossumd8faa362007-04-27 19:54:29 +0000445 if var in os.environ:
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000446 value = os.environ[var]
Guido van Rossumd8faa362007-04-27 19:54:29 +0000447 else:
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000448 value = '%' + var + '%'
449 if isinstance(path, bytes):
450 value = value.encode('ascii')
451 res = res + value
Amaury Forgeot d'Arc3b44e612008-10-03 20:32:33 +0000452 elif c == dollar: # variable or '$$'
453 if path[index + 1:index + 2] == dollar:
Guido van Rossum15e22e11997-12-05 19:03:01 +0000454 res = res + c
455 index = index + 1
Amaury Forgeot d'Arc3b44e612008-10-03 20:32:33 +0000456 elif path[index + 1:index + 2] == brace:
Guido van Rossum15e22e11997-12-05 19:03:01 +0000457 path = path[index+2:]
458 pathlen = len(path)
459 try:
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000460 if isinstance(path, bytes):
461 index = path.index(b'}')
Thomas Woutersb2137042007-02-01 18:02:27 +0000462 else:
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000463 index = path.index('}')
464 var = path[:index]
465 if isinstance(path, bytes):
466 var = var.decode('ascii')
467 if var in os.environ:
468 value = os.environ[var]
469 else:
470 value = '${' + var + '}'
471 if isinstance(path, bytes):
472 value = value.encode('ascii')
473 res = res + value
Fred Drakeb4e460a2000-09-28 16:25:20 +0000474 except ValueError:
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000475 if isinstance(path, bytes):
476 res = res + b'${' + path
477 else:
478 res = res + '${' + path
Guido van Rossum15e22e11997-12-05 19:03:01 +0000479 index = pathlen - 1
480 else:
481 var = ''
482 index = index + 1
483 c = path[index:index + 1]
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000484 while c and c in varchars:
485 if isinstance(path, bytes):
486 var = var + c.decode('ascii')
487 else:
488 var = var + c
Guido van Rossum15e22e11997-12-05 19:03:01 +0000489 index = index + 1
490 c = path[index:index + 1]
Raymond Hettinger54f02222002-06-01 14:18:47 +0000491 if var in os.environ:
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000492 value = os.environ[var]
Thomas Woutersb2137042007-02-01 18:02:27 +0000493 else:
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000494 value = '$' + var
495 if isinstance(path, bytes):
496 value = value.encode('ascii')
497 res = res + value
498 if c:
Thomas Woutersb2137042007-02-01 18:02:27 +0000499 index = index - 1
Guido van Rossum15e22e11997-12-05 19:03:01 +0000500 else:
501 res = res + c
502 index = index + 1
503 return res
Guido van Rossum555915a1994-02-24 11:32:59 +0000504
505
Tim Peters54a14a32001-08-30 22:05:26 +0000506# Normalize a path, e.g. A//B, A/./B and A/foo/../B all become A\B.
Guido van Rossum3df7b5a1996-08-26 16:35:26 +0000507# Previously, this function also truncated pathnames to 8+3 format,
508# but as this module is called "ntpath", that's obviously wrong!
Guido van Rossum555915a1994-02-24 11:32:59 +0000509
510def normpath(path):
Guido van Rossum15e22e11997-12-05 19:03:01 +0000511 """Normalize path, eliminating double slashes, etc."""
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000512 sep = _get_sep(path)
Amaury Forgeot d'Arc3b44e612008-10-03 20:32:33 +0000513 dotdot = _get_dot(path) * 2
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000514 path = path.replace(_get_altsep(path), sep)
Guido van Rossum15e22e11997-12-05 19:03:01 +0000515 prefix, path = splitdrive(path)
Mark Hammond5a607a32009-05-06 08:04:54 +0000516
517 # collapse initial backslashes
518 if path.startswith(sep):
519 prefix = prefix + sep
520 path = path.lstrip(sep)
521
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000522 comps = path.split(sep)
Guido van Rossum15e22e11997-12-05 19:03:01 +0000523 i = 0
524 while i < len(comps):
Amaury Forgeot d'Arc3b44e612008-10-03 20:32:33 +0000525 if not comps[i] or comps[i] == _get_dot(path):
Guido van Rossum15e22e11997-12-05 19:03:01 +0000526 del comps[i]
Amaury Forgeot d'Arc3b44e612008-10-03 20:32:33 +0000527 elif comps[i] == dotdot:
528 if i > 0 and comps[i-1] != dotdot:
Tim Peters54a14a32001-08-30 22:05:26 +0000529 del comps[i-1:i+1]
530 i -= 1
Amaury Forgeot d'Arc3b44e612008-10-03 20:32:33 +0000531 elif i == 0 and prefix.endswith(_get_sep(path)):
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000532 del comps[i]
533 else:
534 i += 1
Guido van Rossum15e22e11997-12-05 19:03:01 +0000535 else:
Tim Peters54a14a32001-08-30 22:05:26 +0000536 i += 1
Guido van Rossum15e22e11997-12-05 19:03:01 +0000537 # If the path is now empty, substitute '.'
538 if not prefix and not comps:
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000539 comps.append(_get_dot(path))
540 return prefix + sep.join(comps)
Guido van Rossume294cf61999-01-29 18:05:18 +0000541
542
543# Return an absolute path.
Thomas Wouters477c8d52006-05-27 19:21:47 +0000544try:
545 from nt import _getfullpathname
Mark Hammondf717f052002-01-17 00:44:26 +0000546
Thomas Wouters477c8d52006-05-27 19:21:47 +0000547except ImportError: # not running on Windows - mock up something sensible
548 def abspath(path):
549 """Return the absolute version of a path."""
550 if not isabs(path):
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000551 if isinstance(path, bytes):
552 cwd = os.getcwdb()
553 else:
554 cwd = os.getcwd()
555 path = join(cwd, path)
Thomas Wouters477c8d52006-05-27 19:21:47 +0000556 return normpath(path)
557
558else: # use native Windows method on Windows
559 def abspath(path):
560 """Return the absolute version of a path."""
561
562 if path: # Empty path must return current working directory.
563 try:
564 path = _getfullpathname(path)
565 except WindowsError:
566 pass # Bad path - return unchanged.
Florent Xiclunaad8c5ca2010-03-08 14:44:41 +0000567 elif isinstance(path, bytes):
568 path = os.getcwdb()
Thomas Wouters477c8d52006-05-27 19:21:47 +0000569 else:
570 path = os.getcwd()
571 return normpath(path)
Guido van Rossum83eeef42001-09-17 15:16:09 +0000572
573# realpath is a no-op on systems without islink support
574realpath = abspath
Mark Hammond8696ebc2002-10-08 02:44:31 +0000575# Win9x family and earlier have no Unicode filename support.
Tim Peters26bc25a2002-10-09 07:56:04 +0000576supports_unicode_filenames = (hasattr(sys, "getwindowsversion") and
577 sys.getwindowsversion()[3] >= 2)
Guido van Rossumd8faa362007-04-27 19:54:29 +0000578
579def relpath(path, start=curdir):
580 """Return a relative version of a path"""
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000581 sep = _get_sep(path)
582
583 if start is curdir:
584 start = _get_dot(path)
Guido van Rossumd8faa362007-04-27 19:54:29 +0000585
586 if not path:
587 raise ValueError("no path specified")
Mark Hammond5a607a32009-05-06 08:04:54 +0000588
589 start_abs = abspath(normpath(start))
590 path_abs = abspath(normpath(path))
591 start_drive, start_rest = splitdrive(start_abs)
592 path_drive, path_rest = splitdrive(path_abs)
593 if start_drive != path_drive:
594 error = "path is on mount '{0}', start on mount '{1}'".format(
595 path_drive, start_drive)
596 raise ValueError(error)
597
598 start_list = [x for x in start_rest.split(sep) if x]
599 path_list = [x for x in path_rest.split(sep) if x]
Guido van Rossumd8faa362007-04-27 19:54:29 +0000600 # Work out how much of the filepath is shared by start and path.
Mark Hammond5a607a32009-05-06 08:04:54 +0000601 i = 0
602 for e1, e2 in zip(start_list, path_list):
603 if e1 != e2:
Guido van Rossumd8faa362007-04-27 19:54:29 +0000604 break
Guido van Rossumd8faa362007-04-27 19:54:29 +0000605 i += 1
606
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000607 if isinstance(path, bytes):
608 pardir = b'..'
609 else:
610 pardir = '..'
Guido van Rossumd8faa362007-04-27 19:54:29 +0000611 rel_list = [pardir] * (len(start_list)-i) + path_list[i:]
Christian Heimesfaf2f632008-01-06 16:59:19 +0000612 if not rel_list:
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000613 return _get_dot(path)
Guido van Rossumd8faa362007-04-27 19:54:29 +0000614 return join(*rel_list)