← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

  • Committer: Martin Pool
  • Date: 2010-01-29 10:36:23 UTC
  • mto: This revision was merged to the branch mainline in revision 4992.
  • Revision ID: mbp@sourcefrog.net-20100129103623-hywka5hymo5z13jw
Change url to canonical.com or wiki, plus some doc improvements in passing

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/win32utils.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
21
21
 
22
22
import glob
23
23
import os
 
24
import re
24
25
import struct
25
26
import sys
26
27
 
27
 
from bzrlib import cmdline
28
28
 
29
29
# Windows version
30
30
if sys.platform == 'win32':
135
135
                'WorkingSetSize': mem_struct.WorkingSetSize,
136
136
                'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
137
137
                'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
138
 
                'QuotaPeakNonPagedPoolUsage':
139
 
                    mem_struct.QuotaPeakNonPagedPoolUsage,
 
138
                'QuotaPeakNonPagedPoolUsage': mem_struct.QuotaPeakNonPagedPoolUsage,
140
139
                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
141
140
                'PagefileUsage': mem_struct.PagefileUsage,
142
141
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
153
152
                   ' or win32process')
154
153
        return
155
154
    if short:
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,
161
159
                   message)
162
160
        return
163
161
    if message:
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))
172
169
 
173
170
 
190
187
 
191
188
    if res:
192
189
        (bufx, bufy, curx, cury, wattr,
193
 
        left, top, right, bottom, maxx, maxy) = struct.unpack(
194
 
            "hhhhHhhhhhh", csbi.raw)
 
190
        left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
195
191
        sizex = right - left + 1
196
192
        sizey = bottom - top + 1
197
193
        return (sizex, sizey)
414
410
 
415
411
 
416
412
def _ensure_with_dir(path):
417
 
    if (not os.path.split(path)[0] or path.startswith(u'*')
418
 
        or path.startswith(u'?')):
 
413
    if not os.path.split(path)[0] or path.startswith(u'*') or path.startswith(u'?'):
419
414
        return u'./' + path, True
420
415
    else:
421
416
        return path, False
522
517
            trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
523
518
 
524
519
 
525
 
def _command_line_to_argv(command_line, single_quotes_allowed=False):
526
 
    """Convert a Unicode command line into a list of argv arguments.
527
 
 
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.
531
 
 
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
535
 
                                  default.
536
 
    :return: A list of unicode strings.
537
 
    """
538
 
    s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
539
 
    # Now that we've split the content, expand globs if necessary
 
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
540
626
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
541
627
    #       '**/' style globs
542
628
    args = []
550
636
 
551
637
if has_ctypes and winver != 'Windows 98':
552
638
    def get_unicode_argv():
553
 
        prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
554
 
        GetCommandLineW = prototype(("GetCommandLineW",
555
 
                                     ctypes.windll.kernel32))
556
 
        command_line = GetCommandLineW()
557
 
        if command_line is None:
558
 
            raise ctypes.WinError()
 
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()
559
647
        # Skip the first argument, since we only care about parameters
560
648
        argv = _command_line_to_argv(command_line)[1:]
561
649
        if getattr(sys, 'frozen', None) is None: