← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

(jam) Handle bug #382709 by encoding paths as 'mbcs' when spawning
        external diff.

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
19
19
Only one dependency: ctypes should be installed.
20
20
"""
21
21
 
22
 
import glob
23
22
import os
24
23
import struct
25
24
import sys
26
25
 
27
 
from bzrlib import cmdline
28
 
from bzrlib.i18n import gettext
29
26
 
30
27
# Windows version
31
28
if sys.platform == 'win32':
129
126
            ctypes.byref(mem_struct),
130
127
            ctypes.sizeof(mem_struct))
131
128
        if not ret:
132
 
            trace.note(gettext('Failed to GetProcessMemoryInfo()'))
 
129
            trace.note('Failed to GetProcessMemoryInfo()')
133
130
            return
134
131
        info = {'PageFaultCount': mem_struct.PageFaultCount,
135
132
                'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
136
133
                'WorkingSetSize': mem_struct.WorkingSetSize,
137
134
                'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
138
135
                'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
139
 
                'QuotaPeakNonPagedPoolUsage':
140
 
                    mem_struct.QuotaPeakNonPagedPoolUsage,
 
136
                'QuotaPeakNonPagedPoolUsage': mem_struct.QuotaPeakNonPagedPoolUsage,
141
137
                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
142
138
                'PagefileUsage': mem_struct.PagefileUsage,
143
139
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
150
146
        proc = win32process.GetCurrentProcess()
151
147
        info = win32process.GetProcessMemoryInfo(proc)
152
148
    else:
153
 
        trace.note(gettext('Cannot debug memory on win32 without ctypes'
154
 
                   ' or win32process'))
 
149
        trace.note('Cannot debug memory on win32 without ctypes'
 
150
                   ' or win32process')
155
151
        return
156
152
    if short:
157
 
        # using base-2 units (see HACKING.txt).
158
 
        trace.note(gettext('WorkingSize {0:>7}KiB'
159
 
                   '\tPeakWorking {1:>7}KiB\t{2}').format(
 
153
        trace.note('WorkingSize %7dKB'
 
154
                   '\tPeakWorking %7dKB\t%s',
160
155
                   info['WorkingSetSize'] / 1024,
161
156
                   info['PeakWorkingSetSize'] / 1024,
162
 
                   message))
 
157
                   message)
163
158
        return
164
159
    if message:
165
160
        trace.note('%s', message)
166
 
    trace.note(gettext('WorkingSize       %8d KiB'), info['WorkingSetSize'] / 1024)
167
 
    trace.note(gettext('PeakWorking       %8d KiB'), info['PeakWorkingSetSize'] / 1024)
168
 
    trace.note(gettext('PagefileUsage     %8d KiB'), info.get('PagefileUsage', 0) / 1024)
169
 
    trace.note(gettext('PeakPagefileUsage %8d KiB'),
170
 
               info.get('PeakPagefileUsage', 0) / 1024)
171
 
    trace.note(gettext('PrivateUsage      %8d KiB'), info.get('PrivateUsage', 0) / 1024)
172
 
    trace.note(gettext('PageFaultCount    %8d'), info.get('PageFaultCount', 0))
 
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)
 
166
    trace.note('PageFaultCount    %8d', info.get('PageFaultCount', 0))
173
167
 
174
168
 
175
169
def get_console_size(defaultx=80, defaulty=25):
184
178
        return (defaultx, defaulty)
185
179
 
186
180
    # To avoid problem with redirecting output via pipe
187
 
    # we need to use stderr instead of stdout
 
181
    # need to use stderr instead of stdout
188
182
    h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
189
183
    csbi = ctypes.create_string_buffer(22)
190
184
    res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
191
185
 
192
186
    if res:
193
187
        (bufx, bufy, curx, cury, wattr,
194
 
        left, top, right, bottom, maxx, maxy) = struct.unpack(
195
 
            "hhhhHhhhhhh", csbi.raw)
 
188
        left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
196
189
        sizex = right - left + 1
197
190
        sizey = bottom - top + 1
198
191
        return (sizex, sizey)
395
388
 
396
389
 
397
390
def _ensure_unicode(s):
 
391
    from bzrlib import osutils
398
392
    if s and type(s) != unicode:
399
393
        from bzrlib import osutils
400
394
        s = s.decode(osutils.get_user_encoding())
415
409
 
416
410
 
417
411
def _ensure_with_dir(path):
418
 
    if (not os.path.split(path)[0] or path.startswith(u'*')
419
 
        or path.startswith(u'?')):
 
412
    if not os.path.split(path)[0] or path.startswith(u'*') or path.startswith(u'?'):
420
413
        return u'./' + path, True
421
414
    else:
422
415
        return path, False
429
422
 
430
423
 
431
424
 
432
 
def glob_one(possible_glob):
433
 
    """Same as glob.glob().
434
 
 
435
 
    work around bugs in glob.glob()
436
 
    - Python bug #1001604 ("glob doesn't return unicode with ...")
437
 
    - failing expansion for */* with non-iso-8859-* chars
438
 
    """
439
 
    corrected_glob, corrected = _ensure_with_dir(possible_glob)
440
 
    glob_files = glob.glob(corrected_glob)
441
 
 
442
 
    if not glob_files:
443
 
        # special case to let the normal code path handle
444
 
        # files that do not exist, etc.
445
 
        glob_files = [possible_glob]
446
 
    elif corrected:
447
 
        glob_files = [_undo_ensure_with_dir(elem, corrected)
448
 
                      for elem in glob_files]
449
 
    return [elem.replace(u'\\', u'/') for elem in glob_files]
450
 
 
451
 
 
452
425
def glob_expand(file_list):
453
426
    """Replacement for glob expansion by the shell.
454
427
 
462
435
    """
463
436
    if not file_list:
464
437
        return []
 
438
    import glob
465
439
    expanded_file_list = []
466
440
    for possible_glob in file_list:
467
 
        expanded_file_list.extend(glob_one(possible_glob))
468
 
    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)
 
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]
469
457
 
470
458
 
471
459
def get_app_path(appname):
472
 
    r"""Look up in Windows registry for full path to application executable.
 
460
    """Look up in Windows registry for full path to application executable.
473
461
    Typically, applications create subkey with their basename
474
462
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
475
463
 
523
511
            trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
524
512
 
525
513
 
526
 
def _command_line_to_argv(command_line, argv, 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
 
    # First, spit the command line
540
 
    s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
541
 
    
542
 
    # Bug #587868 Now make sure that the length of s agrees with sys.argv 
543
 
    # we do this by simply counting the number of arguments in each. The counts should 
544
 
    # agree no matter what encoding sys.argv is in (AFAIK) 
545
 
    # len(arguments) < len(sys.argv) should be an impossibility since python gets 
546
 
    # args from the very same PEB as does GetCommandLineW
547
 
    arguments = list(s)
548
 
    
549
 
    # Now shorten the command line we get from GetCommandLineW to match sys.argv
550
 
    if len(arguments) < len(argv):
551
 
        raise AssertionError("Split command line can't be shorter than argv")
552
 
    arguments = arguments[len(arguments) - len(argv):]
553
 
    
554
 
    # Carry on to process globs (metachars) in the command line
555
 
    # expand globs if necessary
556
 
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
557
 
    #       '**/' style globs
558
 
    args = []
559
 
    for is_quoted, arg in arguments:
560
 
        if is_quoted or not glob.has_magic(arg):
561
 
            args.append(arg)
562
 
        else:
563
 
            args.extend(glob_one(arg))
564
 
    return args
565
 
 
566
 
 
567
514
if has_ctypes and winver != 'Windows 98':
568
515
    def get_unicode_argv():
569
 
        prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
570
 
        GetCommandLineW = prototype(("GetCommandLineW",
571
 
                                     ctypes.windll.kernel32))
572
 
        command_line = GetCommandLineW()
573
 
        if command_line is None:
574
 
            raise ctypes.WinError()
 
516
        LPCWSTR = ctypes.c_wchar_p
 
517
        INT = ctypes.c_int
 
518
        POINTER = ctypes.POINTER
 
519
        prototype = ctypes.WINFUNCTYPE(LPCWSTR)
 
520
        GetCommandLine = prototype(("GetCommandLineW",
 
521
                                    ctypes.windll.kernel32))
 
522
        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))
575
527
        # Skip the first argument, since we only care about parameters
576
 
        argv = _command_line_to_argv(command_line, sys.argv)[1:]
 
528
        argv = [pargv[i] for i in range(1, c.value)]
 
529
        if getattr(sys, 'frozen', None) is None:
 
530
            # Invoked via 'python.exe' which takes the form:
 
531
            #   python.exe [PYTHON_OPTIONS] C:\Path\bzr [BZR_OPTIONS]
 
532
            # 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:]
577
538
        return argv
578
539
else:
579
540
    get_unicode_argv = None
580
 
 
581
 
 
582
 
if has_win32api:
583
 
    def _pywin32_is_local_pid_dead(pid):
584
 
        """True if pid doesn't correspond to live process on this machine"""
585
 
        try:
586
 
            handle = win32api.OpenProcess(1, False, pid) # PROCESS_TERMINATE
587
 
        except pywintypes.error, e:
588
 
            if e[0] == 5: # ERROR_ACCESS_DENIED
589
 
                # Probably something alive we're not allowed to kill
590
 
                return False
591
 
            elif e[0] == 87: # ERROR_INVALID_PARAMETER
592
 
                return True
593
 
            raise
594
 
        handle.close()
595
 
        return False
596
 
    is_local_pid_dead = _pywin32_is_local_pid_dead
597
 
elif has_ctypes and sys.platform == 'win32':
598
 
    from ctypes.wintypes import BOOL, DWORD, HANDLE
599
 
    _kernel32 = ctypes.windll.kernel32
600
 
    _CloseHandle = ctypes.WINFUNCTYPE(BOOL, HANDLE)(
601
 
        ("CloseHandle", _kernel32))
602
 
    _OpenProcess = ctypes.WINFUNCTYPE(HANDLE, DWORD, BOOL, DWORD)(
603
 
        ("OpenProcess", _kernel32))
604
 
    def _ctypes_is_local_pid_dead(pid):
605
 
        """True if pid doesn't correspond to live process on this machine"""
606
 
        handle = _OpenProcess(1, False, pid) # PROCESS_TERMINATE
607
 
        if not handle:
608
 
            errorcode = ctypes.GetLastError()
609
 
            if errorcode == 5: # ERROR_ACCESS_DENIED
610
 
                # Probably something alive we're not allowed to kill
611
 
                return False
612
 
            elif errorcode == 87: # ERROR_INVALID_PARAMETER
613
 
                return True
614
 
            raise ctypes.WinError(errorcode)
615
 
        _CloseHandle(handle)
616
 
        return False
617
 
    is_local_pid_dead = _ctypes_is_local_pid_dead