← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

  • Committer: John Arbash Meinel
  • Date: 2010-08-13 19:08:57 UTC
  • mto: (5050.17.7 2.2)
  • mto: This revision was merged to the branch mainline in revision 5379.
  • Revision ID: john@arbash-meinel.com-20100813190857-mvzwnimrxvm0zimp
Lots of documentation updates.

We had a lot of http links pointing to the old domain. They should
all now be properly updated to the new domain. (only bazaar-vcs.org
entry left is for pqm, which seems to still reside at the old url.)

Also removed one 'TODO' doc entry about switching to binary xdelta, since
we basically did just that with groupcompress.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/win32utils.py
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005-2010 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
22
23
import os
23
24
import struct
24
25
import sys
25
26
 
 
27
from bzrlib import cmdline
26
28
 
27
29
# Windows version
28
30
if sys.platform == 'win32':
66
68
        suffix = 'W'
67
69
try:
68
70
    import win32file
 
71
    import pywintypes
69
72
    has_win32file = True
70
73
except ImportError:
71
74
    has_win32file = False
96
99
UNLEN = 256
97
100
MAX_COMPUTERNAME_LENGTH = 31
98
101
 
 
102
# Registry data type ids
 
103
REG_SZ = 1
 
104
REG_EXPAND_SZ = 2
 
105
 
99
106
 
100
107
def debug_memory_win32api(message='', short=True):
101
108
    """Use trace.note() to dump the running memory info."""
128
135
                'WorkingSetSize': mem_struct.WorkingSetSize,
129
136
                'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
130
137
                'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
131
 
                'QuotaPeakNonPagedPoolUsage': mem_struct.QuotaPeakNonPagedPoolUsage,
 
138
                'QuotaPeakNonPagedPoolUsage':
 
139
                    mem_struct.QuotaPeakNonPagedPoolUsage,
132
140
                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
133
141
                'PagefileUsage': mem_struct.PagefileUsage,
134
142
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
145
153
                   ' or win32process')
146
154
        return
147
155
    if short:
148
 
        trace.note('WorkingSize %7dKB'
149
 
                   '\tPeakWorking %7dKB\t%s',
 
156
        # using base-2 units (see HACKING.txt).
 
157
        trace.note('WorkingSize %7dKiB'
 
158
                   '\tPeakWorking %7dKiB\t%s',
150
159
                   info['WorkingSetSize'] / 1024,
151
160
                   info['PeakWorkingSetSize'] / 1024,
152
161
                   message)
153
162
        return
154
163
    if message:
155
164
        trace.note('%s', message)
156
 
    trace.note('WorkingSize       %8d KB', info['WorkingSetSize'] / 1024)
157
 
    trace.note('PeakWorking       %8d KB', info['PeakWorkingSetSize'] / 1024)
158
 
    trace.note('PagefileUsage     %8d KB', info.get('PagefileUsage', 0) / 1024)
159
 
    trace.note('PeakPagefileUsage %8d KB', info.get('PeakPagefileUsage', 0) / 1024)
160
 
    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)
161
171
    trace.note('PageFaultCount    %8d', info.get('PageFaultCount', 0))
162
172
 
163
173
 
173
183
        return (defaultx, defaulty)
174
184
 
175
185
    # To avoid problem with redirecting output via pipe
176
 
    # need to use stderr instead of stdout
 
186
    # we need to use stderr instead of stdout
177
187
    h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
178
188
    csbi = ctypes.create_string_buffer(22)
179
189
    res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
180
190
 
181
191
    if res:
182
192
        (bufx, bufy, curx, cury, wattr,
183
 
        left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
 
193
        left, top, right, bottom, maxx, maxy) = struct.unpack(
 
194
            "hhhhHhhhhhh", csbi.raw)
184
195
        sizex = right - left + 1
185
196
        sizey = bottom - top + 1
186
197
        return (sizex, sizey)
383
394
 
384
395
 
385
396
def _ensure_unicode(s):
386
 
    from bzrlib import osutils
387
397
    if s and type(s) != unicode:
388
398
        from bzrlib import osutils
389
399
        s = s.decode(osutils.get_user_encoding())
404
414
 
405
415
 
406
416
def _ensure_with_dir(path):
407
 
    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'?')):
408
419
        return u'./' + path, True
409
420
    else:
410
421
        return path, False
417
428
 
418
429
 
419
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
 
420
451
def glob_expand(file_list):
421
452
    """Replacement for glob expansion by the shell.
422
453
 
430
461
    """
431
462
    if not file_list:
432
463
        return []
433
 
    import glob
434
464
    expanded_file_list = []
435
465
    for possible_glob in file_list:
436
 
        # work around bugs in glob.glob()
437
 
        # - Python bug #1001604 ("glob doesn't return unicode with ...")
438
 
        # - failing expansion for */* with non-iso-8859-* chars
439
 
        possible_glob, corrected = _ensure_with_dir(possible_glob)
440
 
        glob_files = glob.glob(possible_glob)
441
 
 
442
 
        if glob_files == []:
443
 
            # special case to let the normal code path handle
444
 
            # files that do not exists
445
 
            expanded_file_list.append(
446
 
                _undo_ensure_with_dir(possible_glob, corrected))
447
 
        else:
448
 
            glob_files = [_undo_ensure_with_dir(elem, corrected) for elem in glob_files]
449
 
            expanded_file_list += glob_files
450
 
 
451
 
    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
452
468
 
453
469
 
454
470
def get_app_path(appname):
462
478
                or appname itself if nothing found.
463
479
    """
464
480
    import _winreg
 
481
 
 
482
    basename = appname
 
483
    if not os.path.splitext(basename)[1]:
 
484
        basename = appname + '.exe'
 
485
 
465
486
    try:
466
487
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
467
 
                               r'SOFTWARE\Microsoft\Windows'
468
 
                               r'\CurrentVersion\App Paths')
 
488
            'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
 
489
            basename)
469
490
    except EnvironmentError:
470
491
        return appname
471
492
 
472
 
    basename = appname
473
 
    if not os.path.splitext(basename)[1]:
474
 
        basename = appname + '.exe'
475
493
    try:
476
494
        try:
477
 
            fullpath = _winreg.QueryValue(hkey, basename)
 
495
            path, type_id = _winreg.QueryValueEx(hkey, '')
478
496
        except WindowsError:
479
 
            fullpath = appname
 
497
            return appname
480
498
    finally:
481
499
        _winreg.CloseKey(hkey)
482
500
 
483
 
    return fullpath
 
501
    if type_id == REG_SZ:
 
502
        return path
 
503
    if type_id == REG_EXPAND_SZ and has_win32api:
 
504
        fullpath = win32api.ExpandEnvironmentStrings(path)
 
505
        if len(fullpath) > 1 and fullpath[0] == '"' and fullpath[-1] == '"':
 
506
            fullpath = fullpath[1:-1]   # remove quotes around value
 
507
        return fullpath
 
508
    return appname
484
509
 
485
510
 
486
511
def set_file_attr_hidden(path):
487
512
    """Set file attributes to hidden if possible"""
488
513
    if has_win32file:
489
 
        win32file.SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
 
514
        if winver != 'Windows 98':
 
515
            SetFileAttributes = win32file.SetFileAttributesW
 
516
        else:
 
517
            SetFileAttributes = win32file.SetFileAttributes
 
518
        try:
 
519
            SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
 
520
        except pywintypes.error, e:
 
521
            from bzrlib import trace
 
522
            trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
 
523
 
 
524
 
 
525
def _command_line_to_argv(command_line, argv, 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
    # First, spit the command line
 
539
    s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
 
540
    
 
541
    # Bug #587868 Now make sure that the length of s agrees with sys.argv 
 
542
    # we do this by simply counting the number of arguments in each. The counts should 
 
543
    # agree no matter what encoding sys.argv is in (AFAIK) 
 
544
    # len(arguments) < len(sys.argv) should be an impossibility since python gets 
 
545
    # args from the very same PEB as does GetCommandLineW
 
546
    arguments = list(s)
 
547
    
 
548
    # Now shorten the command line we get from GetCommandLineW to match sys.argv
 
549
    if len(arguments) < len(argv):
 
550
        raise AssertionError("Split command line can't be shorter than argv")
 
551
    arguments = arguments[len(arguments) - len(argv):]
 
552
    
 
553
    # Carry on to process globs (metachars) in the command line
 
554
    # expand globs if necessary
 
555
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
 
556
    #       '**/' style globs
 
557
    args = []
 
558
    for is_quoted, arg in arguments:
 
559
        if is_quoted or not glob.has_magic(arg):
 
560
            args.append(arg)
 
561
        else:
 
562
            args.extend(glob_one(arg))
 
563
    return args
490
564
 
491
565
 
492
566
if has_ctypes and winver != 'Windows 98':
493
567
    def get_unicode_argv():
494
 
        LPCWSTR = ctypes.c_wchar_p
495
 
        INT = ctypes.c_int
496
 
        POINTER = ctypes.POINTER
497
 
        prototype = ctypes.WINFUNCTYPE(LPCWSTR)
498
 
        GetCommandLine = prototype(("GetCommandLineW",
499
 
                                    ctypes.windll.kernel32))
500
 
        prototype = ctypes.WINFUNCTYPE(POINTER(LPCWSTR), LPCWSTR, POINTER(INT))
501
 
        CommandLineToArgv = prototype(("CommandLineToArgvW",
502
 
                                       ctypes.windll.shell32))
503
 
        c = INT(0)
504
 
        pargv = CommandLineToArgv(GetCommandLine(), ctypes.byref(c))
 
568
        prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
 
569
        GetCommandLineW = prototype(("GetCommandLineW",
 
570
                                     ctypes.windll.kernel32))
 
571
        command_line = GetCommandLineW()
 
572
        if command_line is None:
 
573
            raise ctypes.WinError()
505
574
        # Skip the first argument, since we only care about parameters
506
 
        argv = [pargv[i] for i in range(1, c.value)]
507
 
        if getattr(sys, 'frozen', None) is None:
508
 
            # Invoked via 'python.exe' which takes the form:
509
 
            #   python.exe [PYTHON_OPTIONS] C:\Path\bzr [BZR_OPTIONS]
510
 
            # we need to get only BZR_OPTIONS part,
511
 
            # so let's using sys.argv[1:] as reference to get the tail
512
 
            # of unicode argv
513
 
            tail_len = len(sys.argv[1:])
514
 
            ix = len(argv) - tail_len
515
 
            argv = argv[ix:]
 
575
        argv = _command_line_to_argv(command_line, sys.argv)[1:]
516
576
        return argv
517
577
else:
518
578
    get_unicode_argv = None