← 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: 2009-03-30 18:42:38 UTC
  • mto: (3735.2.171 brisbane-core)
  • mto: This revision was merged to the branch mainline in revision 4280.
  • Revision ID: john@arbash-meinel.com-20090330184238-yc8t2i9wr2mjkxiu
For now, we handle the case of a root node being referenced in the unwanted set.
However, it requires buffering, which is something we want to get rid of.

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
26
 
29
27
# Windows version
30
28
if sys.platform == 'win32':
68
66
        suffix = 'W'
69
67
try:
70
68
    import win32file
71
 
    import pywintypes
72
69
    has_win32file = True
73
70
except ImportError:
74
71
    has_win32file = False
99
96
UNLEN = 256
100
97
MAX_COMPUTERNAME_LENGTH = 31
101
98
 
102
 
# Registry data type ids
103
 
REG_SZ = 1
104
 
REG_EXPAND_SZ = 2
105
 
 
106
99
 
107
100
def debug_memory_win32api(message='', short=True):
108
101
    """Use trace.note() to dump the running memory info."""
135
128
                'WorkingSetSize': mem_struct.WorkingSetSize,
136
129
                'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
137
130
                'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
138
 
                'QuotaPeakNonPagedPoolUsage':
139
 
                    mem_struct.QuotaPeakNonPagedPoolUsage,
 
131
                'QuotaPeakNonPagedPoolUsage': mem_struct.QuotaPeakNonPagedPoolUsage,
140
132
                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
141
133
                'PagefileUsage': mem_struct.PagefileUsage,
142
134
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
153
145
                   ' or win32process')
154
146
        return
155
147
    if short:
156
 
        # using base-2 units (see HACKING.txt).
157
 
        trace.note('WorkingSize %7dKiB'
158
 
                   '\tPeakWorking %7dKiB\t%s',
 
148
        trace.note('WorkingSize %7dKB'
 
149
                   '\tPeakWorking %7dKB\t%s',
159
150
                   info['WorkingSetSize'] / 1024,
160
151
                   info['PeakWorkingSetSize'] / 1024,
161
152
                   message)
162
153
        return
163
154
    if message:
164
155
        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)
 
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)
171
161
    trace.note('PageFaultCount    %8d', info.get('PageFaultCount', 0))
172
162
 
173
163
 
183
173
        return (defaultx, defaulty)
184
174
 
185
175
    # To avoid problem with redirecting output via pipe
186
 
    # we need to use stderr instead of stdout
 
176
    # need to use stderr instead of stdout
187
177
    h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
188
178
    csbi = ctypes.create_string_buffer(22)
189
179
    res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
190
180
 
191
181
    if res:
192
182
        (bufx, bufy, curx, cury, wattr,
193
 
        left, top, right, bottom, maxx, maxy) = struct.unpack(
194
 
            "hhhhHhhhhhh", csbi.raw)
 
183
        left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
195
184
        sizex = right - left + 1
196
185
        sizey = bottom - top + 1
197
186
        return (sizex, sizey)
278
267
 
279
268
    Returned value can be unicode or plain string.
280
269
    To convert plain string to unicode use
281
 
    s.decode(osutils.get_user_encoding())
 
270
    s.decode(bzrlib.user_encoding)
282
271
    (XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
283
272
    """
284
273
    local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
297
286
    If location cannot be obtained return system drive root,
298
287
    i.e. C:\
299
288
 
300
 
    Returned value can be unicode or plain string.
 
289
    Returned value can be unicode or plain sring.
301
290
    To convert plain string to unicode use
302
291
    s.decode(osutils.get_user_encoding())
303
292
    """
320
309
    """Return user name as login name.
321
310
    If name cannot be obtained return None.
322
311
 
323
 
    Returned value can be unicode or plain string.
 
312
    Returned value can be unicode or plain sring.
324
313
    To convert plain string to unicode use
325
314
    s.decode(osutils.get_user_encoding())
326
315
    """
394
383
 
395
384
 
396
385
def _ensure_unicode(s):
 
386
    from bzrlib import osutils
397
387
    if s and type(s) != unicode:
398
388
        from bzrlib import osutils
399
389
        s = s.decode(osutils.get_user_encoding())
414
404
 
415
405
 
416
406
def _ensure_with_dir(path):
417
 
    if (not os.path.split(path)[0] or path.startswith(u'*')
418
 
        or path.startswith(u'?')):
 
407
    if not os.path.split(path)[0] or path.startswith(u'*') or path.startswith(u'?'):
419
408
        return u'./' + path, True
420
409
    else:
421
410
        return path, False
428
417
 
429
418
 
430
419
 
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
 
 
451
420
def glob_expand(file_list):
452
421
    """Replacement for glob expansion by the shell.
453
422
 
461
430
    """
462
431
    if not file_list:
463
432
        return []
 
433
    import glob
464
434
    expanded_file_list = []
465
435
    for possible_glob in file_list:
466
 
        expanded_file_list.extend(glob_one(possible_glob))
467
 
    return expanded_file_list
 
436
 
 
437
        # work around bugs in glob.glob()
 
438
        # - Python bug #1001604 ("glob doesn't return unicode with ...")
 
439
        # - failing expansion for */* with non-iso-8859-* chars
 
440
        possible_glob, corrected = _ensure_with_dir(possible_glob)
 
441
        glob_files = glob.glob(possible_glob)
 
442
 
 
443
        if glob_files == []:
 
444
            # special case to let the normal code path handle
 
445
            # files that do not exists
 
446
            expanded_file_list.append(
 
447
                _undo_ensure_with_dir(possible_glob, corrected))
 
448
        else:
 
449
            glob_files = [_undo_ensure_with_dir(elem, corrected) for elem in glob_files]
 
450
            expanded_file_list += glob_files
 
451
 
 
452
    return [elem.replace(u'\\', u'/') for elem in expanded_file_list]
468
453
 
469
454
 
470
455
def get_app_path(appname):
471
456
    """Look up in Windows registry for full path to application executable.
472
 
    Typically, applications create subkey with their basename
 
457
    Typicaly, applications create subkey with their basename
473
458
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
474
459
 
475
460
    :param  appname:    name of application (if no filename extension
478
463
                or appname itself if nothing found.
479
464
    """
480
465
    import _winreg
 
466
    try:
 
467
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
 
468
                               r'SOFTWARE\Microsoft\Windows'
 
469
                               r'\CurrentVersion\App Paths')
 
470
    except EnvironmentError:
 
471
        return appname
481
472
 
482
473
    basename = appname
483
474
    if not os.path.splitext(basename)[1]:
484
475
        basename = appname + '.exe'
485
 
 
486
 
    try:
487
 
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
488
 
            'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
489
 
            basename)
490
 
    except EnvironmentError:
491
 
        return appname
492
 
 
493
476
    try:
494
477
        try:
495
 
            path, type_id = _winreg.QueryValueEx(hkey, '')
 
478
            fullpath = _winreg.QueryValue(hkey, basename)
496
479
        except WindowsError:
497
 
            return appname
 
480
            fullpath = appname
498
481
    finally:
499
482
        _winreg.CloseKey(hkey)
500
483
 
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
    return fullpath
509
485
 
510
486
 
511
487
def set_file_attr_hidden(path):
512
488
    """Set file attributes to hidden if possible"""
513
489
    if has_win32file:
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
564
 
 
565
 
 
566
 
if has_ctypes and winver != 'Windows 98':
567
 
    def get_unicode_argv():
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()
574
 
        # Skip the first argument, since we only care about parameters
575
 
        argv = _command_line_to_argv(command_line, sys.argv)[1:]
576
 
        return argv
577
 
else:
578
 
    get_unicode_argv = None
 
490
        win32file.SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)