149
164
proc = win32process.GetCurrentProcess()
150
165
info = win32process.GetProcessMemoryInfo(proc)
152
trace.note('Cannot debug memory on win32 without ctypes'
167
trace.note(gettext('Cannot debug memory on win32 without ctypes'
156
171
# using base-2 units (see HACKING.txt).
157
trace.note('WorkingSize %7dKiB'
158
'\tPeakWorking %7dKiB\t%s',
172
trace.note(gettext('WorkingSize {0:>7}KiB'
173
'\tPeakWorking {1:>7}KiB\t{2}').format(
159
174
info['WorkingSetSize'] / 1024,
160
175
info['PeakWorkingSetSize'] / 1024,
164
179
trace.note('%s', message)
165
trace.note('WorkingSize %8d KiB', info['WorkingSetSize'] / 1024)
166
trace.note('PeakWorking %8d KiB', info['PeakWorkingSetSize'] / 1024)
167
trace.note('PagefileUsage %8d KiB', info.get('PagefileUsage', 0) / 1024)
168
trace.note('PeakPagefileUsage %8d KiB',
180
trace.note(gettext('WorkingSize %8d KiB'), info['WorkingSetSize'] / 1024)
181
trace.note(gettext('PeakWorking %8d KiB'), info['PeakWorkingSetSize'] / 1024)
182
trace.note(gettext('PagefileUsage %8d KiB'), info.get('PagefileUsage', 0) / 1024)
183
trace.note(gettext('PeakPagefileUsage %8d KiB'),
169
184
info.get('PeakPagefileUsage', 0) / 1024)
170
trace.note('PrivateUsage %8d KiB', info.get('PrivateUsage', 0) / 1024)
171
trace.note('PageFaultCount %8d', info.get('PageFaultCount', 0))
185
trace.note(gettext('PrivateUsage %8d KiB'), info.get('PrivateUsage', 0) / 1024)
186
trace.note(gettext('PageFaultCount %8d'), info.get('PageFaultCount', 0))
174
189
def get_console_size(defaultx=80, defaulty=25):
242
257
one that moves with the user as they logon to different machines, and
243
258
a 'local' one that stays local to the machine. This returns the 'roaming'
244
259
directory, and thus is suitable for storing user-preferences, etc.
246
Returned value can be unicode or plain string.
247
To convert plain string to unicode use
248
s.decode(osutils.get_user_encoding())
249
(XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
251
261
appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
255
appdata = os.environ.get('APPDATA')
258
# if we fall to this point we on win98
259
# at least try C:/WINDOWS/Application Data
260
windir = os.environ.get('windir')
262
appdata = os.path.join(windir, 'Application Data')
263
if os.path.isdir(appdata):
265
# did not find anything
264
# Use APPDATA if defined, will return None if not
265
return get_environ_unicode('APPDATA')
269
268
def get_local_appdata_location():
296
290
Assume on win32 it's the <My Documents> folder.
297
291
If location cannot be obtained return system drive root,
300
Returned value can be unicode or plain string.
301
To convert plain string to unicode use
302
s.decode(osutils.get_user_encoding())
304
294
home = _get_sh_special_folder_path(CSIDL_PERSONAL)
307
# try for HOME env variable
308
home = os.path.expanduser('~')
297
home = get_environ_unicode('HOME')
300
homepath = get_environ_unicode('HOMEPATH')
301
if homepath is not None:
302
return os.path.join(get_environ_unicode('HOMEDIR', ''), home)
311
303
# at least return windows root directory
312
windir = os.environ.get('windir')
304
windir = get_environ_unicode('WINDIR')
314
306
return os.path.splitdrive(windir)[0] + '/'
315
307
# otherwise C:\ is good enough for 98% users
308
return unicode('C:/')
319
311
def get_user_name():
320
312
"""Return user name as login name.
321
313
If name cannot be obtained return None.
323
Returned value can be unicode or plain string.
324
To convert plain string to unicode use
325
s.decode(osutils.get_user_encoding())
382
369
if (GetComputerName is not None
383
370
and GetComputerName(buf, ctypes.byref(n))):
385
# otherwise try env variables, which will be 'mbcs' encoded
386
# on Windows (Python doesn't expose the native win32 unicode environment)
388
# http://msdn.microsoft.com/en-us/library/aa246807.aspx
389
# environment variables should always be encoded in 'mbcs'.
391
return os.environ['COMPUTERNAME'].decode("mbcs")
371
return extract_buffer(buf)
372
return get_environ_unicode('COMPUTERNAME')
375
@symbol_versioning.deprecated_function(
376
symbol_versioning.deprecated_in((2, 5, 0)))
396
377
def _ensure_unicode(s):
397
378
if s and type(s) != unicode:
398
379
from bzrlib import osutils
403
def get_appdata_location_unicode():
404
return _ensure_unicode(get_appdata_location())
406
def get_home_location_unicode():
407
return _ensure_unicode(get_home_location())
409
def get_user_name_unicode():
410
return _ensure_unicode(get_user_name())
412
def get_host_name_unicode():
413
return _ensure_unicode(get_host_name())
384
get_appdata_location_unicode = symbol_versioning.deprecated_function(
385
symbol_versioning.deprecated_in((2, 5, 0)))(get_appdata_location)
387
get_home_location_unicode = symbol_versioning.deprecated_function(
388
symbol_versioning.deprecated_in((2, 5, 0)))(get_home_location)
390
get_user_name_unicode = symbol_versioning.deprecated_function(
391
symbol_versioning.deprecated_in((2, 5, 0)))(get_user_name)
393
get_host_name_unicode = symbol_versioning.deprecated_function(
394
symbol_versioning.deprecated_in((2, 5, 0)))(get_host_name)
416
397
def _ensure_with_dir(path):
522
502
trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
526
class UnicodeShlex(object):
527
"""This is a very simplified version of shlex.shlex.
529
The main change is that it supports non-ascii input streams. The internal
530
structure is quite simplified relative to shlex.shlex, since we aren't
531
trying to handle multiple input streams, etc. In fact, we don't use a
532
file-like api either.
535
def __init__(self, uni_string):
536
self._input = uni_string
537
self._input_iter = iter(self._input)
538
self._whitespace_match = re.compile(u'\s').match
539
self._word_match = re.compile(u'\S').match
540
self._quote_chars = u'"'
541
# self._quote_match = re.compile(u'[\'"]').match
542
self._escape_match = lambda x: None # Never matches
545
# ' ' - after whitespace, starting a new token
546
# 'a' - after text, currently working on a token
547
# '"' - after ", currently in a "-delimited quoted section
548
# "\" - after '\', checking the next char
550
self._token = [] # Current token being parsed
552
def _get_token(self):
553
# Were there quote chars as part of this token?
556
for nextchar in self._input_iter:
557
if self._state == ' ':
558
if self._whitespace_match(nextchar):
559
# if self._token: return token
561
elif nextchar in self._quote_chars:
562
self._state = nextchar # quoted state
563
elif self._word_match(nextchar):
564
self._token.append(nextchar)
567
raise AssertionError('wtttf?')
568
elif self._state in self._quote_chars:
570
if nextchar == self._state: # End of quote
571
self._state = 'a' # posix allows 'foo'bar to translate to
573
elif self._state == '"' and nextchar == self._escape:
574
quoted_state = self._state
575
self._state = nextchar
577
self._token.append(nextchar)
578
elif self._state == self._escape:
580
self._token.append('\\')
581
elif nextchar == '"':
582
self._token.append(nextchar)
584
self._token.append('\\' + nextchar)
585
self._state = quoted_state
586
elif self._state == 'a':
587
if self._whitespace_match(nextchar):
589
break # emit this token
591
continue # no token to emit
592
elif nextchar in self._quote_chars:
593
# Start a new quoted section
594
self._state = nextchar
596
elif (self._word_match(nextchar)
597
or nextchar in self._quote_chars
598
# or whitespace_split?
600
self._token.append(nextchar)
602
raise AssertionError('state == "a", char: %r'
605
raise AssertionError('unknown state: %r' % (self._state,))
606
result = ''.join(self._token)
608
if not quoted and result == '':
610
return quoted, result
616
quoted, token = self._get_token()
622
def _command_line_to_argv(command_line):
623
"""Convert a Unicode command line into a set of argv arguments.
625
This does wildcard expansion, etc. It is intended to make wildcards act
626
closer to how they work in posix shells, versus how they work by default on
629
s = UnicodeShlex(command_line)
630
# Now that we've split the content, expand globs
505
def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
506
"""Convert a Unicode command line into a list of argv arguments.
508
It performs wildcard expansion to make wildcards act closer to how they
509
work in posix shells, versus how they work by default on Windows. Quoted
510
arguments are left untouched.
512
:param command_line: The unicode string to split into an arg list.
513
:param single_quotes_allowed: Whether single quotes are accepted as quoting
514
characters like double quotes. False by
516
:return: A list of unicode strings.
518
# First, split the command line
519
s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
521
# Bug #587868 Now make sure that the length of s agrees with sys.argv
522
# we do this by simply counting the number of arguments in each. The counts should
523
# agree no matter what encoding sys.argv is in (AFAIK)
524
# len(arguments) < len(sys.argv) should be an impossibility since python gets
525
# args from the very same PEB as does GetCommandLineW
528
# Now shorten the command line we get from GetCommandLineW to match sys.argv
529
if len(arguments) < len(argv):
530
raise AssertionError("Split command line can't be shorter than argv")
531
arguments = arguments[len(arguments) - len(argv):]
533
# Carry on to process globs (metachars) in the command line
534
# expand globs if necessary
631
535
# TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
632
536
# '**/' style globs
634
for is_quoted, arg in s:
538
for is_quoted, arg in arguments:
635
539
if is_quoted or not glob.has_magic(arg):
642
if has_ctypes and winver != 'Windows 98':
546
if has_ctypes and winver == 'Windows NT':
643
547
def get_unicode_argv():
644
LPCWSTR = ctypes.c_wchar_p
646
POINTER = ctypes.POINTER
647
prototype = ctypes.WINFUNCTYPE(LPCWSTR)
648
GetCommandLine = prototype(("GetCommandLineW",
649
ctypes.windll.kernel32))
650
prototype = ctypes.WINFUNCTYPE(POINTER(LPCWSTR), LPCWSTR, POINTER(INT))
651
command_line = GetCommandLine()
548
prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
549
GetCommandLineW = prototype(("GetCommandLineW",
550
ctypes.windll.kernel32))
551
command_line = GetCommandLineW()
552
if command_line is None:
553
raise ctypes.WinError()
652
554
# Skip the first argument, since we only care about parameters
653
argv = _command_line_to_argv(command_line)[1:]
654
if getattr(sys, 'frozen', None) is None:
655
# Invoked via 'python.exe' which takes the form:
656
# python.exe [PYTHON_OPTIONS] C:\Path\bzr [BZR_OPTIONS]
657
# we need to get only BZR_OPTIONS part,
658
# We already removed 'python.exe' so we remove everything up to and
659
# including the first non-option ('-') argument.
660
for idx in xrange(len(argv)):
661
if argv[idx][:1] != '-':
555
argv = _command_line_to_argv(command_line, sys.argv)[1:]
559
def get_environ_unicode(key, default=None):
560
"""Get `key` from environment as unicode or `default` if unset
562
The environment is natively unicode on modern windows versions but
563
Python 2 only accesses it through the legacy bytestring api.
565
Environmental variable names are case insenstive on Windows.
567
A large enough buffer will be allocated to retrieve the value, though
568
it may take two calls to the underlying library function.
570
This needs ctypes because pywin32 does not expose the wide version.
572
cfunc = getattr(get_environ_unicode, "_c_function", None)
574
from ctypes.wintypes import DWORD, LPCWSTR, LPWSTR
575
cfunc = ctypes.WINFUNCTYPE(DWORD, LPCWSTR, LPWSTR, DWORD)(
576
("GetEnvironmentVariableW", ctypes.windll.kernel32))
577
get_environ_unicode._c_function = cfunc
578
buffer_size = 256 # heuristic, 256 characters often enough
580
buffer = ctypes.create_unicode_buffer(buffer_size)
581
length = cfunc(key, buffer, buffer_size)
583
code = ctypes.GetLastError()
584
if code == 203: # ERROR_ENVVAR_NOT_FOUND
586
raise ctypes.WinError(code)
587
if buffer_size > length:
588
return buffer[:length]
666
591
get_unicode_argv = None
592
def get_environ_unicode(key, default=None):
593
"""Get `key` from environment as unicode or `default` if unset
595
Fallback version that should basically never be needed.
597
from bzrlib import osutils
599
return os.environ[key].decode(osutils.get_user_encoding())
605
def _pywin32_is_local_pid_dead(pid):
606
"""True if pid doesn't correspond to live process on this machine"""
608
handle = win32api.OpenProcess(1, False, pid) # PROCESS_TERMINATE
609
except pywintypes.error, e:
610
if e[0] == 5: # ERROR_ACCESS_DENIED
611
# Probably something alive we're not allowed to kill
613
elif e[0] == 87: # ERROR_INVALID_PARAMETER
618
is_local_pid_dead = _pywin32_is_local_pid_dead
619
elif has_ctypes and sys.platform == 'win32':
620
from ctypes.wintypes import BOOL, DWORD, HANDLE
621
_kernel32 = ctypes.windll.kernel32
622
_CloseHandle = ctypes.WINFUNCTYPE(BOOL, HANDLE)(
623
("CloseHandle", _kernel32))
624
_OpenProcess = ctypes.WINFUNCTYPE(HANDLE, DWORD, BOOL, DWORD)(
625
("OpenProcess", _kernel32))
626
def _ctypes_is_local_pid_dead(pid):
627
"""True if pid doesn't correspond to live process on this machine"""
628
handle = _OpenProcess(1, False, pid) # PROCESS_TERMINATE
630
errorcode = ctypes.GetLastError()
631
if errorcode == 5: # ERROR_ACCESS_DENIED
632
# Probably something alive we're not allowed to kill
634
elif errorcode == 87: # ERROR_INVALID_PARAMETER
636
raise ctypes.WinError(errorcode)
639
is_local_pid_dead = _ctypes_is_local_pid_dead
642
def _is_pywintypes_error(evalue):
643
"""True if exception instance is an error from pywin32"""
644
if has_pywintypes and isinstance(evalue, pywintypes.error):
added
removed
bzrlib/win32utils.py
