135
133
'WorkingSetSize': mem_struct.WorkingSetSize,
136
134
'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
137
135
'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
138
'QuotaPeakNonPagedPoolUsage':
139
mem_struct.QuotaPeakNonPagedPoolUsage,
136
'QuotaPeakNonPagedPoolUsage': mem_struct.QuotaPeakNonPagedPoolUsage,
140
137
'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
141
138
'PagefileUsage': mem_struct.PagefileUsage,
142
139
'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
153
150
' or win32process')
156
# using base-2 units (see HACKING.txt).
157
trace.note('WorkingSize %7dKiB'
158
'\tPeakWorking %7dKiB\t%s',
153
trace.note('WorkingSize %7dKB'
154
'\tPeakWorking %7dKB\t%s',
159
155
info['WorkingSetSize'] / 1024,
160
156
info['PeakWorkingSetSize'] / 1024,
164
160
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)
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)
171
166
trace.note('PageFaultCount %8d', info.get('PageFaultCount', 0))
183
178
return (defaultx, defaulty)
185
180
# To avoid problem with redirecting output via pipe
186
# we need to use stderr instead of stdout
181
# need to use stderr instead of stdout
187
182
h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
188
183
csbi = ctypes.create_string_buffer(22)
189
184
res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
192
187
(bufx, bufy, curx, cury, wattr,
193
left, top, right, bottom, maxx, maxy) = struct.unpack(
194
"hhhhHhhhhhh", csbi.raw)
188
left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
195
189
sizex = right - left + 1
196
190
sizey = bottom - top + 1
197
191
return (sizex, sizey)
431
def glob_one(possible_glob):
432
"""Same as glob.glob().
434
work around bugs in glob.glob()
435
- Python bug #1001604 ("glob doesn't return unicode with ...")
436
- failing expansion for */* with non-iso-8859-* chars
438
corrected_glob, corrected = _ensure_with_dir(possible_glob)
439
glob_files = glob.glob(corrected_glob)
442
# special case to let the normal code path handle
443
# files that do not exist, etc.
444
glob_files = [possible_glob]
446
glob_files = [_undo_ensure_with_dir(elem, corrected)
447
for elem in glob_files]
448
return [elem.replace(u'\\', u'/') for elem in glob_files]
451
425
def glob_expand(file_list):
452
426
"""Replacement for glob expansion by the shell.
462
436
if not file_list:
464
439
expanded_file_list = []
465
440
for possible_glob in file_list:
466
expanded_file_list.extend(glob_one(possible_glob))
467
return expanded_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]
470
459
def get_app_path(appname):
522
511
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
631
# TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
634
for is_quoted, arg in s:
635
if is_quoted or not glob.has_magic(arg):
638
args.extend(glob_one(arg))
642
514
if has_ctypes and winver != 'Windows 98':
643
515
def get_unicode_argv():
644
516
LPCWSTR = ctypes.c_wchar_p
648
520
GetCommandLine = prototype(("GetCommandLineW",
649
521
ctypes.windll.kernel32))
650
522
prototype = ctypes.WINFUNCTYPE(POINTER(LPCWSTR), LPCWSTR, POINTER(INT))
651
command_line = GetCommandLine()
523
CommandLineToArgv = prototype(("CommandLineToArgvW",
524
ctypes.windll.shell32))
526
pargv = CommandLineToArgv(GetCommandLine(), ctypes.byref(c))
652
527
# Skip the first argument, since we only care about parameters
653
argv = _command_line_to_argv(command_line)[1:]
528
argv = [pargv[i] for i in range(1, c.value)]
654
529
if getattr(sys, 'frozen', None) is None:
655
530
# Invoked via 'python.exe' which takes the form:
656
531
# python.exe [PYTHON_OPTIONS] C:\Path\bzr [BZR_OPTIONS]
657
532
# 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] != '-':
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
666
540
get_unicode_argv = None
added
removed
bzrlib/win32utils.py
