← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-01-15 04:49:48 UTC
  • mfrom: (3984.5.22 switch-r-183559)
  • Revision ID: pqm@pqm.ubuntu.com-20100115044948-yxz5m3vchxapbq22
(andrew) Add --revision option to 'bzr switch'. (#184559)

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
 
from __future__ import absolute_import
23
 
 
24
22
import glob
25
 
import operator
26
23
import os
 
24
import re
27
25
import struct
28
26
import sys
29
27
 
30
 
from bzrlib import (
31
 
    cmdline,
32
 
    symbol_versioning,
33
 
    )
34
 
from bzrlib.i18n import gettext
35
28
 
36
29
# Windows version
37
30
if sys.platform == 'win32':
69
62
else:
70
63
    if winver == 'Windows 98':
71
64
        create_buffer = ctypes.create_string_buffer
72
 
        def extract_buffer(buf):
73
 
            return buf.value.decode("mbcs")
74
65
        suffix = 'A'
75
66
    else:
76
67
        create_buffer = ctypes.create_unicode_buffer
77
 
        extract_buffer = operator.attrgetter("value")
78
68
        suffix = 'W'
79
69
try:
 
70
    import win32file
80
71
    import pywintypes
81
 
    has_pywintypes = True
82
 
except ImportError:
83
 
    has_pywintypes = has_win32file = has_win32api = False
84
 
else:
85
 
    try:
86
 
        import win32file
87
 
        has_win32file = True
88
 
    except ImportError:
89
 
        has_win32file = False
90
 
    try:
91
 
        import win32api
92
 
        has_win32api = True
93
 
    except ImportError:
94
 
        has_win32api = False
 
72
    has_win32file = True
 
73
except ImportError:
 
74
    has_win32file = False
 
75
try:
 
76
    import win32api
 
77
    has_win32api = True
 
78
except ImportError:
 
79
    has_win32api = False
95
80
 
96
81
# pulling in win32com.shell is a bit of overhead, and normally we don't need
97
82
# it as ctypes is preferred and common.  lazy_imports and "optional"
143
128
            ctypes.byref(mem_struct),
144
129
            ctypes.sizeof(mem_struct))
145
130
        if not ret:
146
 
            trace.note(gettext('Failed to GetProcessMemoryInfo()'))
 
131
            trace.note('Failed to GetProcessMemoryInfo()')
147
132
            return
148
133
        info = {'PageFaultCount': mem_struct.PageFaultCount,
149
134
                'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
150
135
                'WorkingSetSize': mem_struct.WorkingSetSize,
151
136
                'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
152
137
                'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
153
 
                'QuotaPeakNonPagedPoolUsage':
154
 
                    mem_struct.QuotaPeakNonPagedPoolUsage,
 
138
                'QuotaPeakNonPagedPoolUsage': mem_struct.QuotaPeakNonPagedPoolUsage,
155
139
                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
156
140
                'PagefileUsage': mem_struct.PagefileUsage,
157
141
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
164
148
        proc = win32process.GetCurrentProcess()
165
149
        info = win32process.GetProcessMemoryInfo(proc)
166
150
    else:
167
 
        trace.note(gettext('Cannot debug memory on win32 without ctypes'
168
 
                   ' or win32process'))
 
151
        trace.note('Cannot debug memory on win32 without ctypes'
 
152
                   ' or win32process')
169
153
        return
170
154
    if short:
171
 
        # using base-2 units (see HACKING.txt).
172
 
        trace.note(gettext('WorkingSize {0:>7}KiB'
173
 
                   '\tPeakWorking {1:>7}KiB\t{2}').format(
 
155
        trace.note('WorkingSize %7dKB'
 
156
                   '\tPeakWorking %7dKB\t%s',
174
157
                   info['WorkingSetSize'] / 1024,
175
158
                   info['PeakWorkingSetSize'] / 1024,
176
 
                   message))
 
159
                   message)
177
160
        return
178
161
    if message:
179
162
        trace.note('%s', message)
180
 
    trace.note(gettext('WorkingSize       %8d KiB'), info['WorkingSetSize'] / 1024)
181
 
    trace.note(gettext('PeakWorking       %8d KiB'), info['PeakWorkingSetSize'] / 1024)
182
 
    trace.note(gettext('PagefileUsage     %8d KiB'), info.get('PagefileUsage', 0) / 1024)
183
 
    trace.note(gettext('PeakPagefileUsage %8d KiB'),
184
 
               info.get('PeakPagefileUsage', 0) / 1024)
185
 
    trace.note(gettext('PrivateUsage      %8d KiB'), info.get('PrivateUsage', 0) / 1024)
186
 
    trace.note(gettext('PageFaultCount    %8d'), info.get('PageFaultCount', 0))
 
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)
 
168
    trace.note('PageFaultCount    %8d', info.get('PageFaultCount', 0))
187
169
 
188
170
 
189
171
def get_console_size(defaultx=80, defaulty=25):
205
187
 
206
188
    if res:
207
189
        (bufx, bufy, curx, cury, wattr,
208
 
        left, top, right, bottom, maxx, maxy) = struct.unpack(
209
 
            "hhhhHhhhhhh", csbi.raw)
 
190
        left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
210
191
        sizex = right - left + 1
211
192
        sizey = bottom - top + 1
212
193
        return (sizex, sizey)
257
238
    one that moves with the user as they logon to different machines, and
258
239
    a 'local' one that stays local to the machine.  This returns the 'roaming'
259
240
    directory, and thus is suitable for storing user-preferences, etc.
 
241
 
 
242
    Returned value can be unicode or plain string.
 
243
    To convert plain string to unicode use
 
244
    s.decode(osutils.get_user_encoding())
 
245
    (XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
260
246
    """
261
247
    appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
262
248
    if appdata:
263
249
        return appdata
264
 
    # Use APPDATA if defined, will return None if not
265
 
    return get_environ_unicode('APPDATA')
 
250
    # from env variable
 
251
    appdata = os.environ.get('APPDATA')
 
252
    if appdata:
 
253
        return appdata
 
254
    # if we fall to this point we on win98
 
255
    # at least try C:/WINDOWS/Application Data
 
256
    windir = os.environ.get('windir')
 
257
    if windir:
 
258
        appdata = os.path.join(windir, 'Application Data')
 
259
        if os.path.isdir(appdata):
 
260
            return appdata
 
261
    # did not find anything
 
262
    return None
266
263
 
267
264
 
268
265
def get_local_appdata_location():
274
271
    a 'local' one that stays local to the machine.  This returns the 'local'
275
272
    directory, and thus is suitable for caches, temp files and other things
276
273
    which don't need to move with the user.
 
274
 
 
275
    Returned value can be unicode or plain string.
 
276
    To convert plain string to unicode use
 
277
    s.decode(osutils.get_user_encoding())
 
278
    (XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
277
279
    """
278
280
    local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
279
281
    if local:
280
282
        return local
281
283
    # Vista supplies LOCALAPPDATA, but XP and earlier do not.
282
 
    local = get_environ_unicode('LOCALAPPDATA')
 
284
    local = os.environ.get('LOCALAPPDATA')
283
285
    if local:
284
286
        return local
285
287
    return get_appdata_location()
290
292
    Assume on win32 it's the <My Documents> folder.
291
293
    If location cannot be obtained return system drive root,
292
294
    i.e. C:\
 
295
 
 
296
    Returned value can be unicode or plain string.
 
297
    To convert plain string to unicode use
 
298
    s.decode(osutils.get_user_encoding())
293
299
    """
294
300
    home = _get_sh_special_folder_path(CSIDL_PERSONAL)
295
301
    if home:
296
302
        return home
297
 
    home = get_environ_unicode('HOME')
298
 
    if home is not None:
 
303
    # try for HOME env variable
 
304
    home = os.path.expanduser('~')
 
305
    if home != '~':
299
306
        return home
300
 
    homepath = get_environ_unicode('HOMEPATH')
301
 
    if homepath is not None:
302
 
        return os.path.join(get_environ_unicode('HOMEDIR', ''), home)
303
307
    # at least return windows root directory
304
 
    windir = get_environ_unicode('WINDIR')
 
308
    windir = os.environ.get('windir')
305
309
    if windir:
306
310
        return os.path.splitdrive(windir)[0] + '/'
307
311
    # otherwise C:\ is good enough for 98% users
308
 
    return unicode('C:/')
 
312
    return 'C:/'
309
313
 
310
314
 
311
315
def get_user_name():
312
316
    """Return user name as login name.
313
317
    If name cannot be obtained return None.
 
318
 
 
319
    Returned value can be unicode or plain string.
 
320
    To convert plain string to unicode use
 
321
    s.decode(osutils.get_user_encoding())
314
322
    """
315
323
    if has_ctypes:
316
324
        try:
322
330
            buf = create_buffer(UNLEN+1)
323
331
            n = ctypes.c_int(UNLEN+1)
324
332
            if GetUserName(buf, ctypes.byref(n)):
325
 
                return extract_buffer(buf)
 
333
                return buf.value
326
334
    # otherwise try env variables
327
 
    return get_environ_unicode('USERNAME')
 
335
    return os.environ.get('USERNAME', None)
328
336
 
329
337
 
330
338
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
335
343
    """Return host machine name.
336
344
    If name cannot be obtained return None.
337
345
 
338
 
    :return: A unicode string representing the host name.
 
346
    :return: A unicode string representing the host name. On win98, this may be
 
347
        a plain string as win32 api doesn't support unicode.
339
348
    """
340
349
    if has_win32api:
341
350
        try:
358
367
            if (GetComputerNameEx is not None
359
368
                and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
360
369
                                      buf, ctypes.byref(n))):
361
 
                return extract_buffer(buf)
 
370
                return buf.value
362
371
 
363
372
            # Try GetComputerName in case GetComputerNameEx wasn't found
364
373
            # It returns the NETBIOS name, which isn't as good, but still ok.
368
377
                                      None)
369
378
            if (GetComputerName is not None
370
379
                and GetComputerName(buf, ctypes.byref(n))):
371
 
                return extract_buffer(buf)
372
 
    return get_environ_unicode('COMPUTERNAME')
373
 
 
374
 
 
375
 
@symbol_versioning.deprecated_function(
376
 
    symbol_versioning.deprecated_in((2, 5, 0)))
 
380
                return buf.value
 
381
    # otherwise try env variables, which will be 'mbcs' encoded
 
382
    # on Windows (Python doesn't expose the native win32 unicode environment)
 
383
    # According to this:
 
384
    # http://msdn.microsoft.com/en-us/library/aa246807.aspx
 
385
    # environment variables should always be encoded in 'mbcs'.
 
386
    try:
 
387
        return os.environ['COMPUTERNAME'].decode("mbcs")
 
388
    except KeyError:
 
389
        return None
 
390
 
 
391
 
377
392
def _ensure_unicode(s):
378
393
    if s and type(s) != unicode:
379
394
        from bzrlib import osutils
381
396
    return s
382
397
 
383
398
 
384
 
get_appdata_location_unicode = symbol_versioning.deprecated_function(
385
 
    symbol_versioning.deprecated_in((2, 5, 0)))(get_appdata_location)
386
 
 
387
 
get_home_location_unicode = symbol_versioning.deprecated_function(
388
 
    symbol_versioning.deprecated_in((2, 5, 0)))(get_home_location)
389
 
 
390
 
get_user_name_unicode = symbol_versioning.deprecated_function(
391
 
    symbol_versioning.deprecated_in((2, 5, 0)))(get_user_name)
392
 
 
393
 
get_host_name_unicode = symbol_versioning.deprecated_function(
394
 
    symbol_versioning.deprecated_in((2, 5, 0)))(get_host_name)
 
399
def get_appdata_location_unicode():
 
400
    return _ensure_unicode(get_appdata_location())
 
401
 
 
402
def get_home_location_unicode():
 
403
    return _ensure_unicode(get_home_location())
 
404
 
 
405
def get_user_name_unicode():
 
406
    return _ensure_unicode(get_user_name())
 
407
 
 
408
def get_host_name_unicode():
 
409
    return _ensure_unicode(get_host_name())
395
410
 
396
411
 
397
412
def _ensure_with_dir(path):
398
 
    if (not os.path.split(path)[0] or path.startswith(u'*')
399
 
        or path.startswith(u'?')):
 
413
    if not os.path.split(path)[0] or path.startswith(u'*') or path.startswith(u'?'):
400
414
        return u'./' + path, True
401
415
    else:
402
416
        return path, False
408
422
        return path
409
423
 
410
424
 
 
425
 
411
426
def glob_one(possible_glob):
412
427
    """Same as glob.glob().
413
428
 
448
463
 
449
464
 
450
465
def get_app_path(appname):
451
 
    r"""Look up in Windows registry for full path to application executable.
 
466
    """Look up in Windows registry for full path to application executable.
452
467
    Typically, applications create subkey with their basename
453
468
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
454
469
 
502
517
            trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
503
518
 
504
519
 
505
 
def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
506
 
    """Convert a Unicode command line into a list of argv arguments.
507
 
 
508
 
    It performs wildcard expansion to make wildcards act closer to how they
509
 
    work in posix shells, versus how they work by default on Windows. Quoted
510
 
    arguments are left untouched.
511
 
 
512
 
    :param command_line: The unicode string to split into an arg list.
513
 
    :param single_quotes_allowed: Whether single quotes are accepted as quoting
514
 
                                  characters like double quotes. False by
515
 
                                  default.
516
 
    :return: A list of unicode strings.
517
 
    """
518
 
    # First, split the command line
519
 
    s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
520
 
    
521
 
    # Bug #587868 Now make sure that the length of s agrees with sys.argv 
522
 
    # we do this by simply counting the number of arguments in each. The counts should 
523
 
    # agree no matter what encoding sys.argv is in (AFAIK) 
524
 
    # len(arguments) < len(sys.argv) should be an impossibility since python gets 
525
 
    # args from the very same PEB as does GetCommandLineW
526
 
    arguments = list(s)
527
 
    
528
 
    # Now shorten the command line we get from GetCommandLineW to match sys.argv
529
 
    if len(arguments) < len(argv):
530
 
        raise AssertionError("Split command line can't be shorter than argv")
531
 
    arguments = arguments[len(arguments) - len(argv):]
532
 
    
533
 
    # Carry on to process globs (metachars) in the command line
534
 
    # 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
535
626
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
536
627
    #       '**/' style globs
537
628
    args = []
538
 
    for is_quoted, arg in arguments:
 
629
    for is_quoted, arg in s:
539
630
        if is_quoted or not glob.has_magic(arg):
540
631
            args.append(arg)
541
632
        else:
543
634
    return args
544
635
 
545
636
 
546
 
if has_ctypes and winver == 'Windows NT':
 
637
if has_ctypes and winver != 'Windows 98':
547
638
    def get_unicode_argv():
548
 
        prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
549
 
        GetCommandLineW = prototype(("GetCommandLineW",
550
 
                                     ctypes.windll.kernel32))
551
 
        command_line = GetCommandLineW()
552
 
        if command_line is None:
553
 
            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()
554
647
        # Skip the first argument, since we only care about parameters
555
 
        argv = _command_line_to_argv(command_line, sys.argv)[1:]
 
648
        argv = _command_line_to_argv(command_line)[1:]
 
649
        if getattr(sys, 'frozen', None) is None:
 
650
            # Invoked via 'python.exe' which takes the form:
 
651
            #   python.exe [PYTHON_OPTIONS] C:\Path\bzr [BZR_OPTIONS]
 
652
            # we need to get only BZR_OPTIONS part,
 
653
            # We already removed 'python.exe' so we remove everything up to and
 
654
            # including the first non-option ('-') argument.
 
655
            for idx in xrange(len(argv)):
 
656
                if argv[idx][:1] != '-':
 
657
                    break
 
658
            argv = argv[idx+1:]
556
659
        return argv
557
 
    
558
 
 
559
 
    def get_environ_unicode(key, default=None):
560
 
        """Get `key` from environment as unicode or `default` if unset
561
 
 
562
 
        The environment is natively unicode on modern windows versions but
563
 
        Python 2 only accesses it through the legacy bytestring api.
564
 
 
565
 
        Environmental variable names are case insenstive on Windows.
566
 
 
567
 
        A large enough buffer will be allocated to retrieve the value, though
568
 
        it may take two calls to the underlying library function.
569
 
 
570
 
        This needs ctypes because pywin32 does not expose the wide version.
571
 
        """
572
 
        cfunc = getattr(get_environ_unicode, "_c_function", None)
573
 
        if cfunc is None:
574
 
            from ctypes.wintypes import DWORD, LPCWSTR, LPWSTR
575
 
            cfunc = ctypes.WINFUNCTYPE(DWORD, LPCWSTR, LPWSTR, DWORD)(
576
 
                ("GetEnvironmentVariableW", ctypes.windll.kernel32))
577
 
            get_environ_unicode._c_function = cfunc
578
 
        buffer_size = 256 # heuristic, 256 characters often enough
579
 
        while True:
580
 
            buffer = ctypes.create_unicode_buffer(buffer_size)
581
 
            length = cfunc(key, buffer, buffer_size)
582
 
            if not length:
583
 
                code = ctypes.GetLastError()
584
 
                if code == 203: # ERROR_ENVVAR_NOT_FOUND
585
 
                    return default
586
 
                raise ctypes.WinError(code)
587
 
            if buffer_size > length:
588
 
                return buffer[:length]
589
 
            buffer_size = length
590
660
else:
591
661
    get_unicode_argv = None
592
 
    def get_environ_unicode(key, default=None):
593
 
        """Get `key` from environment as unicode or `default` if unset
594
 
 
595
 
        Fallback version that should basically never be needed.
596
 
        """
597
 
        from bzrlib import osutils
598
 
        try:
599
 
            return os.environ[key].decode(osutils.get_user_encoding())
600
 
        except KeyError:
601
 
            return default
602
 
 
603
 
 
604
 
if has_win32api:
605
 
    def _pywin32_is_local_pid_dead(pid):
606
 
        """True if pid doesn't correspond to live process on this machine"""
607
 
        try:
608
 
            handle = win32api.OpenProcess(1, False, pid) # PROCESS_TERMINATE
609
 
        except pywintypes.error, e:
610
 
            if e[0] == 5: # ERROR_ACCESS_DENIED
611
 
                # Probably something alive we're not allowed to kill
612
 
                return False
613
 
            elif e[0] == 87: # ERROR_INVALID_PARAMETER
614
 
                return True
615
 
            raise
616
 
        handle.close()
617
 
        return False
618
 
    is_local_pid_dead = _pywin32_is_local_pid_dead
619
 
elif has_ctypes and sys.platform == 'win32':
620
 
    from ctypes.wintypes import BOOL, DWORD, HANDLE
621
 
    _kernel32 = ctypes.windll.kernel32
622
 
    _CloseHandle = ctypes.WINFUNCTYPE(BOOL, HANDLE)(
623
 
        ("CloseHandle", _kernel32))
624
 
    _OpenProcess = ctypes.WINFUNCTYPE(HANDLE, DWORD, BOOL, DWORD)(
625
 
        ("OpenProcess", _kernel32))
626
 
    def _ctypes_is_local_pid_dead(pid):
627
 
        """True if pid doesn't correspond to live process on this machine"""
628
 
        handle = _OpenProcess(1, False, pid) # PROCESS_TERMINATE
629
 
        if not handle:
630
 
            errorcode = ctypes.GetLastError()
631
 
            if errorcode == 5: # ERROR_ACCESS_DENIED
632
 
                # Probably something alive we're not allowed to kill
633
 
                return False
634
 
            elif errorcode == 87: # ERROR_INVALID_PARAMETER
635
 
                return True
636
 
            raise ctypes.WinError(errorcode)
637
 
        _CloseHandle(handle)
638
 
        return False
639
 
    is_local_pid_dead = _ctypes_is_local_pid_dead
640
 
 
641
 
 
642
 
def _is_pywintypes_error(evalue):
643
 
    """True if exception instance is an error from pywin32"""
644
 
    if has_pywintypes and isinstance(evalue, pywintypes.error):
645
 
        return True
646
 
    return False