153
152
' or win32process')
156
# using base-2 units (see HACKING.txt).
157
trace.note('WorkingSize %7dKiB'
158
'\tPeakWorking %7dKiB\t%s',
155
trace.note('WorkingSize %7dKB'
156
'\tPeakWorking %7dKB\t%s',
159
157
info['WorkingSetSize'] / 1024,
160
158
info['PeakWorkingSetSize'] / 1024,
164
162
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',
169
info.get('PeakPagefileUsage', 0) / 1024)
170
trace.note('PrivateUsage %8d KiB', info.get('PrivateUsage', 0) / 1024)
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)
171
168
trace.note('PageFaultCount %8d', info.get('PageFaultCount', 0))
522
517
trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
525
def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
526
"""Convert a Unicode command line into a list of argv arguments.
528
It performs wildcard expansion to make wildcards act closer to how they
529
work in posix shells, versus how they work by default on Windows. Quoted
530
arguments are left untouched.
532
:param command_line: The unicode string to split into an arg list.
533
:param single_quotes_allowed: Whether single quotes are accepted as quoting
534
characters like double quotes. False by
536
:return: A list of unicode strings.
538
# First, spit the command line
539
s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
541
# Bug #587868 Now make sure that the length of s agrees with sys.argv
542
# we do this by simply counting the number of arguments in each. The counts should
543
# agree no matter what encoding sys.argv is in (AFAIK)
544
# len(arguments) < len(sys.argv) should be an impossibility since python gets
545
# args from the very same PEB as does GetCommandLineW
548
# Now shorten the command line we get from GetCommandLineW to match sys.argv
549
if len(arguments) < len(argv):
550
raise AssertionError("Split command line can't be shorter than argv")
551
arguments = arguments[len(arguments) - len(argv):]
553
# Carry on to process globs (metachars) in the command line
554
# expand globs if necessary
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
555
626
# TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
556
627
# '**/' style globs
558
for is_quoted, arg in arguments:
629
for is_quoted, arg in s:
559
630
if is_quoted or not glob.has_magic(arg):
566
637
if has_ctypes and winver != 'Windows 98':
567
638
def get_unicode_argv():
568
prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
569
GetCommandLineW = prototype(("GetCommandLineW",
570
ctypes.windll.kernel32))
571
command_line = GetCommandLineW()
572
if command_line is None:
573
raise ctypes.WinError()
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()
574
647
# Skip the first argument, since we only care about parameters
575
argv = _command_line_to_argv(command_line, sys.argv)[1:]
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] != '-':
578
661
get_unicode_argv = None
added
removed
bzrlib/win32utils.py
