~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

  • Committer: Robert Collins
  • Date: 2010-04-08 04:34:03 UTC
  • mfrom: (5138 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5139.
  • Revision ID: robertc@robertcollins.net-20100408043403-56z0d07vdqrx7f3t
Update bugfix for 528114 to trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
25
25
import struct
26
26
import sys
27
27
 
 
28
from bzrlib import cmdline
28
29
 
29
30
# Windows version
30
31
if sys.platform == 'win32':
135
136
                'WorkingSetSize': mem_struct.WorkingSetSize,
136
137
                'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
137
138
                'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
138
 
                'QuotaPeakNonPagedPoolUsage': mem_struct.QuotaPeakNonPagedPoolUsage,
 
139
                'QuotaPeakNonPagedPoolUsage':
 
140
                    mem_struct.QuotaPeakNonPagedPoolUsage,
139
141
                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
140
142
                'PagefileUsage': mem_struct.PagefileUsage,
141
143
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
152
154
                   ' or win32process')
153
155
        return
154
156
    if short:
155
 
        trace.note('WorkingSize %7dKB'
156
 
                   '\tPeakWorking %7dKB\t%s',
 
157
        # using base-2 units (see HACKING.txt).
 
158
        trace.note('WorkingSize %7dKiB'
 
159
                   '\tPeakWorking %7dKiB\t%s',
157
160
                   info['WorkingSetSize'] / 1024,
158
161
                   info['PeakWorkingSetSize'] / 1024,
159
162
                   message)
160
163
        return
161
164
    if message:
162
165
        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)
 
166
    trace.note('WorkingSize       %8d KiB', info['WorkingSetSize'] / 1024)
 
167
    trace.note('PeakWorking       %8d KiB', info['PeakWorkingSetSize'] / 1024)
 
168
    trace.note('PagefileUsage     %8d KiB', info.get('PagefileUsage', 0) / 1024)
 
169
    trace.note('PeakPagefileUsage %8d KiB',
 
170
               info.get('PeakPagefileUsage', 0) / 1024)
 
171
    trace.note('PrivateUsage      %8d KiB', info.get('PrivateUsage', 0) / 1024)
168
172
    trace.note('PageFaultCount    %8d', info.get('PageFaultCount', 0))
169
173
 
170
174
 
187
191
 
188
192
    if res:
189
193
        (bufx, bufy, curx, cury, wattr,
190
 
        left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
 
194
        left, top, right, bottom, maxx, maxy) = struct.unpack(
 
195
            "hhhhHhhhhhh", csbi.raw)
191
196
        sizex = right - left + 1
192
197
        sizey = bottom - top + 1
193
198
        return (sizex, sizey)
410
415
 
411
416
 
412
417
def _ensure_with_dir(path):
413
 
    if not os.path.split(path)[0] or path.startswith(u'*') or path.startswith(u'?'):
 
418
    if (not os.path.split(path)[0] or path.startswith(u'*')
 
419
        or path.startswith(u'?')):
414
420
        return u'./' + path, True
415
421
    else:
416
422
        return path, False
517
523
            trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
518
524
 
519
525
 
520
 
 
521
 
class UnicodeShlex(object):
522
 
    """This is a very simplified version of shlex.shlex.
523
 
 
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.
528
 
    """
529
 
 
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
538
 
        self._escape = '\\'
539
 
        # State can be
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
544
 
        self._state = ' '
545
 
        self._token = [] # Current token being parsed
546
 
 
547
 
    def _get_token(self):
548
 
        # Were there quote chars as part of this token?
549
 
        quoted = False
550
 
        quoted_state = None
551
 
        for nextchar in self._input_iter:
552
 
            if self._state == ' ':
553
 
                if self._whitespace_match(nextchar):
554
 
                    # if self._token: return token
555
 
                    continue
556
 
                elif nextchar in self._quote_chars:
557
 
                    self._state = nextchar # quoted state
558
 
                elif self._word_match(nextchar):
559
 
                    self._token.append(nextchar)
560
 
                    self._state = 'a'
561
 
                else:
562
 
                    raise AssertionError('wtttf?')
563
 
            elif self._state in self._quote_chars:
564
 
                quoted = True
565
 
                if nextchar == self._state: # End of quote
566
 
                    self._state = 'a' # posix allows 'foo'bar to translate to
567
 
                                      # foobar
568
 
                elif self._state == '"' and nextchar == self._escape:
569
 
                    quoted_state = self._state
570
 
                    self._state = nextchar
571
 
                else:
572
 
                    self._token.append(nextchar)
573
 
            elif self._state == self._escape:
574
 
                if nextchar == '\\':
575
 
                    self._token.append('\\')
576
 
                elif nextchar == '"':
577
 
                    self._token.append(nextchar)
578
 
                else:
579
 
                    self._token.append('\\' + nextchar)
580
 
                self._state = quoted_state
581
 
            elif self._state == 'a':
582
 
                if self._whitespace_match(nextchar):
583
 
                    if self._token:
584
 
                        break # emit this token
585
 
                    else:
586
 
                        continue # no token to emit
587
 
                elif nextchar in self._quote_chars:
588
 
                    # Start a new quoted section
589
 
                    self._state = nextchar
590
 
                # escape?
591
 
                elif (self._word_match(nextchar)
592
 
                      or nextchar in self._quote_chars
593
 
                      # or whitespace_split?
594
 
                      ):
595
 
                    self._token.append(nextchar)
596
 
                else:
597
 
                    raise AssertionError('state == "a", char: %r'
598
 
                                         % (nextchar,))
599
 
            else:
600
 
                raise AssertionError('unknown state: %r' % (self._state,))
601
 
        result = ''.join(self._token)
602
 
        self._token = []
603
 
        if not quoted and result == '':
604
 
            result = None
605
 
        return quoted, result
606
 
 
607
 
    def __iter__(self):
608
 
        return self
609
 
 
610
 
    def next(self):
611
 
        quoted, token = self._get_token()
612
 
        if token is None:
613
 
            raise StopIteration
614
 
        return quoted, token
615
 
 
616
 
 
617
 
def _command_line_to_argv(command_line):
618
 
    """Convert a Unicode command line into a set of argv arguments.
619
 
 
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
622
 
    Windows.
623
 
    """
624
 
    s = UnicodeShlex(command_line)
625
 
    # Now that we've split the content, expand globs
 
526
def _command_line_to_argv(command_line, single_quotes_allowed=False):
 
527
    """Convert a Unicode command line into a list of argv arguments.
 
528
 
 
529
    It performs wildcard expansion to make wildcards act closer to how they
 
530
    work in posix shells, versus how they work by default on Windows. Quoted
 
531
    arguments are left untouched.
 
532
 
 
533
    :param command_line: The unicode string to split into an arg list.
 
534
    :param single_quotes_allowed: Whether single quotes are accepted as quoting
 
535
                                  characters like double quotes. False by
 
536
                                  default.
 
537
    :return: A list of unicode strings.
 
538
    """
 
539
    s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
 
540
    # Now that we've split the content, expand globs if necessary
626
541
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
627
542
    #       '**/' style globs
628
543
    args = []
636
551
 
637
552
if has_ctypes and winver != 'Windows 98':
638
553
    def get_unicode_argv():
639
 
        LPCWSTR = ctypes.c_wchar_p
640
 
        INT = ctypes.c_int
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()
 
554
        prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
 
555
        GetCommandLineW = prototype(("GetCommandLineW",
 
556
                                     ctypes.windll.kernel32))
 
557
        command_line = GetCommandLineW()
 
558
        if command_line is None:
 
559
            raise ctypes.WinError()
647
560
        # Skip the first argument, since we only care about parameters
648
561
        argv = _command_line_to_argv(command_line)[1:]
649
562
        if getattr(sys, 'frozen', None) is None: