146
164
proc = win32process.GetCurrentProcess()
147
165
info = win32process.GetProcessMemoryInfo(proc)
149
trace.note('Cannot debug memory on win32 without ctypes'
167
trace.note(gettext('Cannot debug memory on win32 without ctypes'
153
trace.note('WorkingSize %7dKB'
154
'\tPeakWorking %7dKB\t%s',
171
# using base-2 units (see HACKING.txt).
172
trace.note(gettext('WorkingSize {0:>7}KiB'
173
'\tPeakWorking {1:>7}KiB\t{2}').format(
155
174
info['WorkingSetSize'] / 1024,
156
175
info['PeakWorkingSetSize'] / 1024,
160
179
trace.note('%s', message)
161
trace.note('WorkingSize %8d KB', info['WorkingSetSize'] / 1024)
162
trace.note('PeakWorking %8d KB', info['PeakWorkingSetSize'] / 1024)
163
trace.note('PagefileUsage %8d KB', info.get('PagefileUsage', 0) / 1024)
164
trace.note('PeakPagefileUsage %8d KB', info.get('PeakPagefileUsage', 0) / 1024)
165
trace.note('PrivateUsage %8d KB', info.get('PrivateUsage', 0) / 1024)
166
trace.note('PageFaultCount %8d', info.get('PageFaultCount', 0))
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'),
184
info.get('PeakPagefileUsage', 0) / 1024)
185
trace.note(gettext('PrivateUsage %8d KiB'), info.get('PrivateUsage', 0) / 1024)
186
trace.note(gettext('PageFaultCount %8d'), info.get('PageFaultCount', 0))
169
189
def get_console_size(defaultx=80, defaulty=25):
290
290
Assume on win32 it's the <My Documents> folder.
291
291
If location cannot be obtained return system drive root,
294
Returned value can be unicode or plain string.
295
To convert plain string to unicode use
296
s.decode(osutils.get_user_encoding())
298
294
home = _get_sh_special_folder_path(CSIDL_PERSONAL)
301
# try for HOME env variable
302
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)
305
303
# at least return windows root directory
306
windir = os.environ.get('windir')
304
windir = get_environ_unicode('WINDIR')
308
306
return os.path.splitdrive(windir)[0] + '/'
309
307
# otherwise C:\ is good enough for 98% users
308
return unicode('C:/')
313
311
def get_user_name():
314
312
"""Return user name as login name.
315
313
If name cannot be obtained return None.
317
Returned value can be unicode or plain string.
318
To convert plain string to unicode use
319
s.decode(osutils.get_user_encoding())
376
369
if (GetComputerName is not None
377
370
and GetComputerName(buf, ctypes.byref(n))):
379
# otherwise try env variables, which will be 'mbcs' encoded
380
# on Windows (Python doesn't expose the native win32 unicode environment)
382
# http://msdn.microsoft.com/en-us/library/aa246807.aspx
383
# environment variables should always be encoded in 'mbcs'.
385
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)))
390
377
def _ensure_unicode(s):
391
from bzrlib import osutils
392
378
if s and type(s) != unicode:
393
379
from bzrlib import osutils
394
380
s = s.decode(osutils.get_user_encoding())
398
def get_appdata_location_unicode():
399
return _ensure_unicode(get_appdata_location())
401
def get_home_location_unicode():
402
return _ensure_unicode(get_home_location())
404
def get_user_name_unicode():
405
return _ensure_unicode(get_user_name())
407
def get_host_name_unicode():
408
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)
411
397
def _ensure_with_dir(path):
412
if not os.path.split(path)[0] or path.startswith(u'*') or path.startswith(u'?'):
398
if (not os.path.split(path)[0] or path.startswith(u'*')
399
or path.startswith(u'?')):
413
400
return u'./' + path, True
415
402
return path, False
436
442
if not file_list:
439
444
expanded_file_list = []
440
445
for possible_glob in file_list:
441
# work around bugs in glob.glob()
442
# - Python bug #1001604 ("glob doesn't return unicode with ...")
443
# - failing expansion for */* with non-iso-8859-* chars
444
possible_glob, corrected = _ensure_with_dir(possible_glob)
445
glob_files = glob.glob(possible_glob)
448
# special case to let the normal code path handle
449
# files that do not exists
450
expanded_file_list.append(
451
_undo_ensure_with_dir(possible_glob, corrected))
453
glob_files = [_undo_ensure_with_dir(elem, corrected) for elem in glob_files]
454
expanded_file_list += glob_files
456
return [elem.replace(u'\\', u'/') for elem in expanded_file_list]
446
expanded_file_list.extend(glob_one(possible_glob))
447
return expanded_file_list
459
450
def get_app_path(appname):
460
"""Look up in Windows registry for full path to application executable.
451
r"""Look up in Windows registry for full path to application executable.
461
452
Typically, applications create subkey with their basename
462
453
in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
511
502
trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
514
if has_ctypes and winver != 'Windows 98':
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
535
# TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
538
for is_quoted, arg in arguments:
539
if is_quoted or not glob.has_magic(arg):
542
args.extend(glob_one(arg))
546
if has_ctypes and winver == 'Windows NT':
515
547
def get_unicode_argv():
516
LPCWSTR = ctypes.c_wchar_p
518
POINTER = ctypes.POINTER
519
prototype = ctypes.WINFUNCTYPE(LPCWSTR)
520
GetCommandLine = prototype(("GetCommandLineW",
521
ctypes.windll.kernel32))
522
prototype = ctypes.WINFUNCTYPE(POINTER(LPCWSTR), LPCWSTR, POINTER(INT))
523
CommandLineToArgv = prototype(("CommandLineToArgvW",
524
ctypes.windll.shell32))
526
pargv = CommandLineToArgv(GetCommandLine(), ctypes.byref(c))
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()
527
554
# Skip the first argument, since we only care about parameters
528
argv = [pargv[i] for i in range(1, c.value)]
529
if getattr(sys, 'frozen', None) is None:
530
# Invoked via 'python.exe' which takes the form:
531
# python.exe [PYTHON_OPTIONS] C:\Path\bzr [BZR_OPTIONS]
532
# we need to get only BZR_OPTIONS part,
533
# so let's using sys.argv[1:] as reference to get the tail
535
tail_len = len(sys.argv[1:])
536
ix = len(argv) - tail_len
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]
540
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
