← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

  • Committer: Vincent Ladeuil
  • Date: 2010-02-09 20:33:43 UTC
  • mto: (5029.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5030.
  • Revision ID: v.ladeuil+lp@free.fr-20100209203343-ktxx7t0xvptvjnt1
Move TestingPathFilteringServer to bzrlib.tests.test_server

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/win32utils.py
19
19
Only one dependency: ctypes should be installed.
20
20
"""
21
21
 
 
22
import glob
22
23
import os
 
24
import re
23
25
import struct
24
26
import sys
25
27
 
133
135
                'WorkingSetSize': mem_struct.WorkingSetSize,
134
136
                'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
135
137
                'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
136
 
                'QuotaPeakNonPagedPoolUsage': mem_struct.QuotaPeakNonPagedPoolUsage,
 
138
                'QuotaPeakNonPagedPoolUsage':
 
139
                    mem_struct.QuotaPeakNonPagedPoolUsage,
137
140
                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
138
141
                'PagefileUsage': mem_struct.PagefileUsage,
139
142
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
150
153
                   ' or win32process')
151
154
        return
152
155
    if short:
153
 
        trace.note('WorkingSize %7dKB'
154
 
                   '\tPeakWorking %7dKB\t%s',
 
156
        # using base-2 units (see HACKING.txt).
 
157
        trace.note('WorkingSize %7dKiB'
 
158
                   '\tPeakWorking %7dKiB\t%s',
155
159
                   info['WorkingSetSize'] / 1024,
156
160
                   info['PeakWorkingSetSize'] / 1024,
157
161
                   message)
158
162
        return
159
163
    if message:
160
164
        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)
 
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)
166
171
    trace.note('PageFaultCount    %8d', info.get('PageFaultCount', 0))
167
172
 
168
173
 
178
183
        return (defaultx, defaulty)
179
184
 
180
185
    # To avoid problem with redirecting output via pipe
181
 
    # need to use stderr instead of stdout
 
186
    # we need to use stderr instead of stdout
182
187
    h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
183
188
    csbi = ctypes.create_string_buffer(22)
184
189
    res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
185
190
 
186
191
    if res:
187
192
        (bufx, bufy, curx, cury, wattr,
188
 
        left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
 
193
        left, top, right, bottom, maxx, maxy) = struct.unpack(
 
194
            "hhhhHhhhhhh", csbi.raw)
189
195
        sizex = right - left + 1
190
196
        sizey = bottom - top + 1
191
197
        return (sizex, sizey)
388
394
 
389
395
 
390
396
def _ensure_unicode(s):
391
 
    from bzrlib import osutils
392
397
    if s and type(s) != unicode:
393
398
        from bzrlib import osutils
394
399
        s = s.decode(osutils.get_user_encoding())
409
414
 
410
415
 
411
416
def _ensure_with_dir(path):
412
 
    if not os.path.split(path)[0] or path.startswith(u'*') or path.startswith(u'?'):
 
417
    if (not os.path.split(path)[0] or path.startswith(u'*')
 
418
        or path.startswith(u'?')):
413
419
        return u'./' + path, True
414
420
    else:
415
421
        return path, False
422
428
 
423
429
 
424
430
 
 
431
def glob_one(possible_glob):
 
432
    """Same as glob.glob().
 
433
 
 
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
 
437
    """
 
438
    corrected_glob, corrected = _ensure_with_dir(possible_glob)
 
439
    glob_files = glob.glob(corrected_glob)
 
440
 
 
441
    if not glob_files:
 
442
        # special case to let the normal code path handle
 
443
        # files that do not exist, etc.
 
444
        glob_files = [possible_glob]
 
445
    elif corrected:
 
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]
 
449
 
 
450
 
425
451
def glob_expand(file_list):
426
452
    """Replacement for glob expansion by the shell.
427
453
 
435
461
    """
436
462
    if not file_list:
437
463
        return []
438
 
    import glob
439
464
    expanded_file_list = []
440
465
    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)
446
 
 
447
 
        if glob_files == []:
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))
452
 
        else:
453
 
            glob_files = [_undo_ensure_with_dir(elem, corrected) for elem in glob_files]
454
 
            expanded_file_list += glob_files
455
 
 
456
 
    return [elem.replace(u'\\', u'/') for elem in expanded_file_list]
 
466
        expanded_file_list.extend(glob_one(possible_glob))
 
467
    return expanded_file_list
457
468
 
458
469
 
459
470
def get_app_path(appname):
511
522
            trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
512
523
 
513
524
 
 
525
 
 
526
class UnicodeShlex(object):
 
527
    """This is a very simplified version of shlex.shlex.
 
528
 
 
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.
 
533
    """
 
534
 
 
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
 
543
        self._escape = '\\'
 
544
        # State can be
 
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
 
549
        self._state = ' '
 
550
        self._token = [] # Current token being parsed
 
551
 
 
552
    def _get_token(self):
 
553
        # Were there quote chars as part of this token?
 
554
        quoted = False
 
555
        quoted_state = None
 
556
        for nextchar in self._input_iter:
 
557
            if self._state == ' ':
 
558
                if self._whitespace_match(nextchar):
 
559
                    # if self._token: return token
 
560
                    continue
 
561
                elif nextchar in self._quote_chars:
 
562
                    self._state = nextchar # quoted state
 
563
                elif self._word_match(nextchar):
 
564
                    self._token.append(nextchar)
 
565
                    self._state = 'a'
 
566
                else:
 
567
                    raise AssertionError('wtttf?')
 
568
            elif self._state in self._quote_chars:
 
569
                quoted = True
 
570
                if nextchar == self._state: # End of quote
 
571
                    self._state = 'a' # posix allows 'foo'bar to translate to
 
572
                                      # foobar
 
573
                elif self._state == '"' and nextchar == self._escape:
 
574
                    quoted_state = self._state
 
575
                    self._state = nextchar
 
576
                else:
 
577
                    self._token.append(nextchar)
 
578
            elif self._state == self._escape:
 
579
                if nextchar == '\\':
 
580
                    self._token.append('\\')
 
581
                elif nextchar == '"':
 
582
                    self._token.append(nextchar)
 
583
                else:
 
584
                    self._token.append('\\' + nextchar)
 
585
                self._state = quoted_state
 
586
            elif self._state == 'a':
 
587
                if self._whitespace_match(nextchar):
 
588
                    if self._token:
 
589
                        break # emit this token
 
590
                    else:
 
591
                        continue # no token to emit
 
592
                elif nextchar in self._quote_chars:
 
593
                    # Start a new quoted section
 
594
                    self._state = nextchar
 
595
                # escape?
 
596
                elif (self._word_match(nextchar)
 
597
                      or nextchar in self._quote_chars
 
598
                      # or whitespace_split?
 
599
                      ):
 
600
                    self._token.append(nextchar)
 
601
                else:
 
602
                    raise AssertionError('state == "a", char: %r'
 
603
                                         % (nextchar,))
 
604
            else:
 
605
                raise AssertionError('unknown state: %r' % (self._state,))
 
606
        result = ''.join(self._token)
 
607
        self._token = []
 
608
        if not quoted and result == '':
 
609
            result = None
 
610
        return quoted, result
 
611
 
 
612
    def __iter__(self):
 
613
        return self
 
614
 
 
615
    def next(self):
 
616
        quoted, token = self._get_token()
 
617
        if token is None:
 
618
            raise StopIteration
 
619
        return quoted, token
 
620
 
 
621
 
 
622
def _command_line_to_argv(command_line):
 
623
    """Convert a Unicode command line into a set of argv arguments.
 
624
 
 
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
 
627
    Windows.
 
628
    """
 
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
 
632
    #       '**/' style globs
 
633
    args = []
 
634
    for is_quoted, arg in s:
 
635
        if is_quoted or not glob.has_magic(arg):
 
636
            args.append(arg)
 
637
        else:
 
638
            args.extend(glob_one(arg))
 
639
    return args
 
640
 
 
641
 
514
642
if has_ctypes and winver != 'Windows 98':
515
643
    def get_unicode_argv():
516
644
        LPCWSTR = ctypes.c_wchar_p
520
648
        GetCommandLine = prototype(("GetCommandLineW",
521
649
                                    ctypes.windll.kernel32))
522
650
        prototype = ctypes.WINFUNCTYPE(POINTER(LPCWSTR), LPCWSTR, POINTER(INT))
523
 
        CommandLineToArgv = prototype(("CommandLineToArgvW",
524
 
                                       ctypes.windll.shell32))
525
 
        c = INT(0)
526
 
        pargv = CommandLineToArgv(GetCommandLine(), ctypes.byref(c))
 
651
        command_line = GetCommandLine()
527
652
        # Skip the first argument, since we only care about parameters
528
 
        argv = [pargv[i] for i in range(1, c.value)]
 
653
        argv = _command_line_to_argv(command_line)[1:]
529
654
        if getattr(sys, 'frozen', None) is None:
530
655
            # Invoked via 'python.exe' which takes the form:
531
656
            #   python.exe [PYTHON_OPTIONS] C:\Path\bzr [BZR_OPTIONS]
532
657
            # we need to get only BZR_OPTIONS part,
533
 
            # so let's using sys.argv[1:] as reference to get the tail
534
 
            # of unicode argv
535
 
            tail_len = len(sys.argv[1:])
536
 
            ix = len(argv) - tail_len
537
 
            argv = argv[ix:]
 
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] != '-':
 
662
                    break
 
663
            argv = argv[idx+1:]
538
664
        return argv
539
665
else:
540
666
    get_unicode_argv = None