82
100
MAX_COMPUTERNAME_LENGTH = 31
102
# Registry data type ids
107
def debug_memory_win32api(message='', short=True):
108
"""Use trace.note() to dump the running memory info."""
109
from bzrlib import trace
111
class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
112
"""Used by GetProcessMemoryInfo"""
113
_fields_ = [('cb', ctypes.c_ulong),
114
('PageFaultCount', ctypes.c_ulong),
115
('PeakWorkingSetSize', ctypes.c_size_t),
116
('WorkingSetSize', ctypes.c_size_t),
117
('QuotaPeakPagedPoolUsage', ctypes.c_size_t),
118
('QuotaPagedPoolUsage', ctypes.c_size_t),
119
('QuotaPeakNonPagedPoolUsage', ctypes.c_size_t),
120
('QuotaNonPagedPoolUsage', ctypes.c_size_t),
121
('PagefileUsage', ctypes.c_size_t),
122
('PeakPagefileUsage', ctypes.c_size_t),
123
('PrivateUsage', ctypes.c_size_t),
125
cur_process = ctypes.windll.kernel32.GetCurrentProcess()
126
mem_struct = PROCESS_MEMORY_COUNTERS_EX()
127
ret = ctypes.windll.psapi.GetProcessMemoryInfo(cur_process,
128
ctypes.byref(mem_struct),
129
ctypes.sizeof(mem_struct))
131
trace.note('Failed to GetProcessMemoryInfo()')
133
info = {'PageFaultCount': mem_struct.PageFaultCount,
134
'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
135
'WorkingSetSize': mem_struct.WorkingSetSize,
136
'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
137
'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
138
'QuotaPeakNonPagedPoolUsage': mem_struct.QuotaPeakNonPagedPoolUsage,
139
'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
140
'PagefileUsage': mem_struct.PagefileUsage,
141
'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
142
'PrivateUsage': mem_struct.PrivateUsage,
146
# win32process does not return PrivateUsage, because it doesn't use
147
# PROCESS_MEMORY_COUNTERS_EX (it uses the one without _EX).
148
proc = win32process.GetCurrentProcess()
149
info = win32process.GetProcessMemoryInfo(proc)
151
trace.note('Cannot debug memory on win32 without ctypes'
155
trace.note('WorkingSize %7dKB'
156
'\tPeakWorking %7dKB\t%s',
157
info['WorkingSetSize'] / 1024,
158
info['PeakWorkingSetSize'] / 1024,
162
trace.note('%s', message)
163
trace.note('WorkingSize %8d KB', info['WorkingSetSize'] / 1024)
164
trace.note('PeakWorking %8d KB', info['PeakWorkingSetSize'] / 1024)
165
trace.note('PagefileUsage %8d KB', info.get('PagefileUsage', 0) / 1024)
166
trace.note('PeakPagefileUsage %8d KB', info.get('PeakPagefileUsage', 0) / 1024)
167
trace.note('PrivateUsage %8d KB', info.get('PrivateUsage', 0) / 1024)
168
trace.note('PageFaultCount %8d', info.get('PageFaultCount', 0))
85
171
def get_console_size(defaultx=80, defaulty=25):
86
172
"""Return size of current console.
109
195
return (defaultx, defaulty)
198
def _get_sh_special_folder_path(csidl):
199
"""Call SHGetSpecialFolderPathW if available, or return None.
201
Result is always unicode (or None).
205
SHGetSpecialFolderPath = \
206
ctypes.windll.shell32.SHGetSpecialFolderPathW
207
except AttributeError:
210
buf = ctypes.create_unicode_buffer(MAX_PATH)
211
if SHGetSpecialFolderPath(None,buf,csidl,0):
214
global has_win32com_shell
215
if has_win32com_shell is None:
217
from win32com.shell import shell
218
has_win32com_shell = True
220
has_win32com_shell = False
221
if has_win32com_shell:
222
# still need to bind the name locally, but this is fast.
223
from win32com.shell import shell
225
return shell.SHGetSpecialFolderPath(0, csidl, 0)
227
# possibly E_NOTIMPL meaning we can't load the function pointer,
228
# or E_FAIL meaning the function failed - regardless, just ignore it
112
233
def get_appdata_location():
113
234
"""Return Application Data location.
114
235
Return None if we cannot obtain location.
116
Returned value can be unicode or plain sring.
237
Windows defines two 'Application Data' folders per user - a 'roaming'
238
one that moves with the user as they logon to different machines, and
239
a 'local' one that stays local to the machine. This returns the 'roaming'
240
directory, and thus is suitable for storing user-preferences, etc.
242
Returned value can be unicode or plain string.
117
243
To convert plain string to unicode use
118
s.decode(bzrlib.user_encoding)
244
s.decode(osutils.get_user_encoding())
245
(XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
122
SHGetSpecialFolderPath = \
123
ctypes.windll.shell32.SHGetSpecialFolderPathW
124
except AttributeError:
127
buf = ctypes.create_unicode_buffer(MAX_PATH)
128
if SHGetSpecialFolderPath(None,buf,CSIDL_APPDATA,0):
247
appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
130
250
# from env variable
131
251
appdata = os.environ.get('APPDATA')
265
def get_local_appdata_location():
266
"""Return Local Application Data location.
267
Return the same as get_appdata_location() if we cannot obtain location.
269
Windows defines two 'Application Data' folders per user - a 'roaming'
270
one that moves with the user as they logon to different machines, and
271
a 'local' one that stays local to the machine. This returns the 'local'
272
directory, and thus is suitable for caches, temp files and other things
273
which don't need to move with the user.
275
Returned value can be unicode or plain string.
276
To convert plain string to unicode use
277
s.decode(osutils.get_user_encoding())
278
(XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
280
local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
283
# Vista supplies LOCALAPPDATA, but XP and earlier do not.
284
local = os.environ.get('LOCALAPPDATA')
287
return get_appdata_location()
145
290
def get_home_location():
146
291
"""Return user's home location.
147
292
Assume on win32 it's the <My Documents> folder.
148
293
If location cannot be obtained return system drive root,
151
Returned value can be unicode or plain sring.
296
Returned value can be unicode or plain string.
152
297
To convert plain string to unicode use
153
s.decode(bzrlib.user_encoding)
298
s.decode(osutils.get_user_encoding())
157
SHGetSpecialFolderPath = \
158
ctypes.windll.shell32.SHGetSpecialFolderPathW
159
except AttributeError:
162
buf = ctypes.create_unicode_buffer(MAX_PATH)
163
if SHGetSpecialFolderPath(None,buf,CSIDL_PERSONAL,0):
300
home = _get_sh_special_folder_path(CSIDL_PERSONAL)
165
303
# try for HOME env variable
166
304
home = os.path.expanduser('~')
197
335
return os.environ.get('USERNAME', None)
338
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
339
# computer or the cluster associated with the local computer."
340
_WIN32_ComputerNameDnsHostname = 1
200
342
def get_host_name():
201
343
"""Return host machine name.
202
344
If name cannot be obtained return None.
204
Returned value can be unicode or plain sring.
205
To convert plain string to unicode use
206
s.decode(bzrlib.user_encoding)
346
:return: A unicode string representing the host name. On win98, this may be
347
a plain string as win32 api doesn't support unicode.
351
return win32api.GetComputerNameEx(_WIN32_ComputerNameDnsHostname)
352
except (NotImplementedError, win32api.error):
353
# NotImplemented will happen on win9x...
210
357
kernel32 = ctypes.windll.kernel32
211
GetComputerName = getattr(kernel32, 'GetComputerName'+suffix)
212
358
except AttributeError:
359
pass # Missing the module we need
215
361
buf = create_buffer(MAX_COMPUTERNAME_LENGTH+1)
216
362
n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
217
if GetComputerName(buf, ctypes.byref(n)):
219
# otherwise try env variables
220
return os.environ.get('COMPUTERNAME', None)
364
# Try GetComputerNameEx which gives a proper Unicode hostname
365
GetComputerNameEx = getattr(kernel32, 'GetComputerNameEx'+suffix,
367
if (GetComputerNameEx is not None
368
and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
369
buf, ctypes.byref(n))):
372
# Try GetComputerName in case GetComputerNameEx wasn't found
373
# It returns the NETBIOS name, which isn't as good, but still ok.
374
# The first GetComputerNameEx might have changed 'n', so reset it
375
n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
376
GetComputerName = getattr(kernel32, 'GetComputerName'+suffix,
378
if (GetComputerName is not None
379
and GetComputerName(buf, ctypes.byref(n))):
381
# otherwise try env variables, which will be 'mbcs' encoded
382
# on Windows (Python doesn't expose the native win32 unicode environment)
384
# http://msdn.microsoft.com/en-us/library/aa246807.aspx
385
# environment variables should always be encoded in 'mbcs'.
387
return os.environ['COMPUTERNAME'].decode("mbcs")
223
392
def _ensure_unicode(s):
224
393
if s and type(s) != unicode:
226
s = s.decode(bzrlib.user_encoding)
394
from bzrlib import osutils
395
s = s.decode(osutils.get_user_encoding())
230
399
def get_appdata_location_unicode():
231
400
return _ensure_unicode(get_appdata_location())
239
408
def get_host_name_unicode():
240
409
return _ensure_unicode(get_host_name())
412
def _ensure_with_dir(path):
413
if not os.path.split(path)[0] or path.startswith(u'*') or path.startswith(u'?'):
414
return u'./' + path, True
418
def _undo_ensure_with_dir(path, corrected):
426
def glob_one(possible_glob):
427
"""Same as glob.glob().
429
work around bugs in glob.glob()
430
- Python bug #1001604 ("glob doesn't return unicode with ...")
431
- failing expansion for */* with non-iso-8859-* chars
433
corrected_glob, corrected = _ensure_with_dir(possible_glob)
434
glob_files = glob.glob(corrected_glob)
437
# special case to let the normal code path handle
438
# files that do not exist, etc.
439
glob_files = [possible_glob]
441
glob_files = [_undo_ensure_with_dir(elem, corrected)
442
for elem in glob_files]
443
return [elem.replace(u'\\', u'/') for elem in glob_files]
446
def glob_expand(file_list):
447
"""Replacement for glob expansion by the shell.
449
Win32's cmd.exe does not do glob expansion (eg ``*.py``), so we do our own
452
:param file_list: A list of filenames which may include shell globs.
453
:return: An expanded list of filenames.
455
Introduced in bzrlib 0.18.
459
expanded_file_list = []
460
for possible_glob in file_list:
461
expanded_file_list.extend(glob_one(possible_glob))
462
return expanded_file_list
465
def get_app_path(appname):
466
"""Look up in Windows registry for full path to application executable.
467
Typically, applications create subkey with their basename
468
in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
470
:param appname: name of application (if no filename extension
471
is specified, .exe used)
472
:return: full path to aplication executable from registry,
473
or appname itself if nothing found.
478
if not os.path.splitext(basename)[1]:
479
basename = appname + '.exe'
482
hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
483
'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
485
except EnvironmentError:
490
path, type_id = _winreg.QueryValueEx(hkey, '')
494
_winreg.CloseKey(hkey)
496
if type_id == REG_SZ:
498
if type_id == REG_EXPAND_SZ and has_win32api:
499
fullpath = win32api.ExpandEnvironmentStrings(path)
500
if len(fullpath) > 1 and fullpath[0] == '"' and fullpath[-1] == '"':
501
fullpath = fullpath[1:-1] # remove quotes around value
506
def set_file_attr_hidden(path):
507
"""Set file attributes to hidden if possible"""
509
if winver != 'Windows 98':
510
SetFileAttributes = win32file.SetFileAttributesW
512
SetFileAttributes = win32file.SetFileAttributes
514
SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
515
except pywintypes.error, e:
516
from bzrlib import trace
517
trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
521
class UnicodeShlex(object):
522
"""This is a very simplified version of shlex.shlex.
524
The main change is that it supports non-ascii input streams. The internal
525
structure is quite simplified relative to shlex.shlex, since we aren't
526
trying to handle multiple input streams, etc. In fact, we don't use a
527
file-like api either.
530
def __init__(self, uni_string):
531
self._input = uni_string
532
self._input_iter = iter(self._input)
533
self._whitespace_match = re.compile(u'\s').match
534
self._word_match = re.compile(u'\S').match
535
self._quote_chars = u'"'
536
# self._quote_match = re.compile(u'[\'"]').match
537
self._escape_match = lambda x: None # Never matches
540
# ' ' - after whitespace, starting a new token
541
# 'a' - after text, currently working on a token
542
# '"' - after ", currently in a "-delimited quoted section
543
# "\" - after '\', checking the next char
545
self._token = [] # Current token being parsed
547
def _get_token(self):
548
# Were there quote chars as part of this token?
551
for nextchar in self._input_iter:
552
if self._state == ' ':
553
if self._whitespace_match(nextchar):
554
# if self._token: return token
556
elif nextchar in self._quote_chars:
557
self._state = nextchar # quoted state
558
elif self._word_match(nextchar):
559
self._token.append(nextchar)
562
raise AssertionError('wtttf?')
563
elif self._state in self._quote_chars:
565
if nextchar == self._state: # End of quote
566
self._state = 'a' # posix allows 'foo'bar to translate to
568
elif self._state == '"' and nextchar == self._escape:
569
quoted_state = self._state
570
self._state = nextchar
572
self._token.append(nextchar)
573
elif self._state == self._escape:
575
self._token.append('\\')
576
elif nextchar == '"':
577
self._token.append(nextchar)
579
self._token.append('\\' + nextchar)
580
self._state = quoted_state
581
elif self._state == 'a':
582
if self._whitespace_match(nextchar):
584
break # emit this token
586
continue # no token to emit
587
elif nextchar in self._quote_chars:
588
# Start a new quoted section
589
self._state = nextchar
591
elif (self._word_match(nextchar)
592
or nextchar in self._quote_chars
593
# or whitespace_split?
595
self._token.append(nextchar)
597
raise AssertionError('state == "a", char: %r'
600
raise AssertionError('unknown state: %r' % (self._state,))
601
result = ''.join(self._token)
603
if not quoted and result == '':
605
return quoted, result
611
quoted, token = self._get_token()
617
def _command_line_to_argv(command_line):
618
"""Convert a Unicode command line into a set of argv arguments.
620
This does wildcard expansion, etc. It is intended to make wildcards act
621
closer to how they work in posix shells, versus how they work by default on
624
s = UnicodeShlex(command_line)
625
# Now that we've split the content, expand globs
626
# TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
629
for is_quoted, arg in s:
630
if is_quoted or not glob.has_magic(arg):
633
args.extend(glob_one(arg))
637
if has_ctypes and winver != 'Windows 98':
638
def get_unicode_argv():
639
LPCWSTR = ctypes.c_wchar_p
641
POINTER = ctypes.POINTER
642
prototype = ctypes.WINFUNCTYPE(LPCWSTR)
643
GetCommandLine = prototype(("GetCommandLineW",
644
ctypes.windll.kernel32))
645
prototype = ctypes.WINFUNCTYPE(POINTER(LPCWSTR), LPCWSTR, POINTER(INT))
646
command_line = GetCommandLine()
647
# Skip the first argument, since we only care about parameters
648
argv = _command_line_to_argv(command_line)[1:]
649
if getattr(sys, 'frozen', None) is None:
650
# Invoked via 'python.exe' which takes the form:
651
# python.exe [PYTHON_OPTIONS] C:\Path\bzr [BZR_OPTIONS]
652
# we need to get only BZR_OPTIONS part,
653
# We already removed 'python.exe' so we remove everything up to and
654
# including the first non-option ('-') argument.
655
for idx in xrange(len(argv)):
656
if argv[idx][:1] != '-':
661
get_unicode_argv = None
added
removed
bzrlib/win32utils.py
