/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

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
 
from __future__ import absolute_import
23
 
 
24
22
import glob
25
 
import operator
26
23
import os
27
24
import struct
28
25
import sys
29
26
 
30
 
from breezy import (
31
 
    cmdline,
32
 
    )
33
 
from breezy.i18n import gettext
 
27
from bzrlib import cmdline
 
28
 
 
29
# Windows version
 
30
if sys.platform == 'win32':
 
31
    _major,_minor,_build,_platform,_text = sys.getwindowsversion()
 
32
    # from MSDN:
 
33
    # dwPlatformId
 
34
    #   The operating system platform.
 
35
    #   This member can be one of the following values.
 
36
    #   ==========================  ======================================
 
37
    #   Value                       Meaning
 
38
    #   --------------------------  --------------------------------------
 
39
    #   VER_PLATFORM_WIN32_NT       The operating system is Windows Vista,
 
40
    #   2                           Windows Server "Longhorn",
 
41
    #                               Windows Server 2003, Windows XP,
 
42
    #                               Windows 2000, or Windows NT.
 
43
    #
 
44
    #   VER_PLATFORM_WIN32_WINDOWS  The operating system is Windows Me,
 
45
    #   1                           Windows 98, or Windows 95.
 
46
    #   ==========================  ======================================
 
47
    if _platform == 2:
 
48
        winver = 'Windows NT'
 
49
    else:
 
50
        # don't care about real Windows name, just to force safe operations
 
51
        winver = 'Windows 98'
 
52
else:
 
53
    winver = None
 
54
 
34
55
 
35
56
# We can cope without it; use a separate variable to help pyflakes
36
57
try:
39
60
except ImportError:
40
61
    has_ctypes = False
41
62
else:
42
 
    create_buffer = ctypes.create_unicode_buffer
43
 
    extract_buffer = operator.attrgetter("value")
44
 
    suffix = 'W'
 
63
    if winver == 'Windows 98':
 
64
        create_buffer = ctypes.create_string_buffer
 
65
        suffix = 'A'
 
66
    else:
 
67
        create_buffer = ctypes.create_unicode_buffer
 
68
        suffix = 'W'
45
69
try:
 
70
    import win32file
46
71
    import pywintypes
47
 
    has_pywintypes = True
48
 
except ImportError:
49
 
    has_pywintypes = has_win32file = has_win32api = False
50
 
else:
51
 
    try:
52
 
        import win32file
53
 
        has_win32file = True
54
 
    except ImportError:
55
 
        has_win32file = False
56
 
    try:
57
 
        import win32api
58
 
        has_win32api = True
59
 
    except ImportError:
60
 
        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
61
80
 
62
81
# pulling in win32com.shell is a bit of overhead, and normally we don't need
63
82
# it as ctypes is preferred and common.  lazy_imports and "optional"
64
83
# modules don't work well, so we do our own lazy thing...
65
 
has_win32com_shell = None  # Set to True or False once we know for sure...
 
84
has_win32com_shell = None # Set to True or False once we know for sure...
66
85
 
67
86
# Special Win32 API constants
68
87
# Handles of std streams
72
91
 
73
92
# CSIDL constants (from MSDN 2003)
74
93
CSIDL_APPDATA = 0x001A      # Application Data folder
75
 
# <user name>\Local Settings\Application Data (non roaming)
76
 
CSIDL_LOCAL_APPDATA = 0x001c
 
94
CSIDL_LOCAL_APPDATA = 0x001c# <user name>\Local Settings\Application Data (non roaming)
77
95
CSIDL_PERSONAL = 0x0005     # My Documents folder
78
96
 
79
97
# from winapi C headers
88
106
 
89
107
def debug_memory_win32api(message='', short=True):
90
108
    """Use trace.note() to dump the running memory info."""
91
 
    from breezy import trace
 
109
    from bzrlib import trace
92
110
    if has_ctypes:
93
111
        class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
94
112
            """Used by GetProcessMemoryInfo"""
103
121
                        ('PagefileUsage', ctypes.c_size_t),
104
122
                        ('PeakPagefileUsage', ctypes.c_size_t),
105
123
                        ('PrivateUsage', ctypes.c_size_t),
106
 
                        ]
 
124
                       ]
107
125
        cur_process = ctypes.windll.kernel32.GetCurrentProcess()
108
126
        mem_struct = PROCESS_MEMORY_COUNTERS_EX()
109
 
        ret = ctypes.windll.psapi.GetProcessMemoryInfo(
110
 
            cur_process, ctypes.byref(mem_struct), ctypes.sizeof(mem_struct))
 
127
        ret = ctypes.windll.psapi.GetProcessMemoryInfo(cur_process,
 
128
            ctypes.byref(mem_struct),
 
129
            ctypes.sizeof(mem_struct))
111
130
        if not ret:
112
 
            trace.note(gettext('Failed to GetProcessMemoryInfo()'))
 
131
            trace.note('Failed to GetProcessMemoryInfo()')
113
132
            return
114
133
        info = {'PageFaultCount': mem_struct.PageFaultCount,
115
134
                'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
122
141
                'PagefileUsage': mem_struct.PagefileUsage,
123
142
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
124
143
                'PrivateUsage': mem_struct.PrivateUsage,
125
 
                }
 
144
               }
126
145
    elif has_win32api:
127
146
        import win32process
128
147
        # win32process does not return PrivateUsage, because it doesn't use
130
149
        proc = win32process.GetCurrentProcess()
131
150
        info = win32process.GetProcessMemoryInfo(proc)
132
151
    else:
133
 
        trace.note(gettext('Cannot debug memory on win32 without ctypes'
134
 
                           ' or win32process'))
 
152
        trace.note('Cannot debug memory on win32 without ctypes'
 
153
                   ' or win32process')
135
154
        return
136
155
    if short:
137
156
        # using base-2 units (see HACKING.txt).
138
 
        trace.note(gettext('WorkingSize {0:>7}KiB'
139
 
                           '\tPeakWorking {1:>7}KiB\t{2}').format(
 
157
        trace.note('WorkingSize %7dKiB'
 
158
                   '\tPeakWorking %7dKiB\t%s',
140
159
                   info['WorkingSetSize'] / 1024,
141
160
                   info['PeakWorkingSetSize'] / 1024,
142
 
                   message))
 
161
                   message)
143
162
        return
144
163
    if message:
145
164
        trace.note('%s', message)
146
 
    trace.note(gettext('WorkingSize       %8d KiB'),
147
 
               info['WorkingSetSize'] / 1024)
148
 
    trace.note(gettext('PeakWorking       %8d KiB'),
149
 
               info['PeakWorkingSetSize'] / 1024)
150
 
    trace.note(gettext('PagefileUsage     %8d KiB'),
151
 
               info.get('PagefileUsage', 0) / 1024)
152
 
    trace.note(gettext('PeakPagefileUsage %8d KiB'),
 
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',
153
169
               info.get('PeakPagefileUsage', 0) / 1024)
154
 
    trace.note(gettext('PrivateUsage      %8d KiB'),
155
 
               info.get('PrivateUsage', 0) / 1024)
156
 
    trace.note(gettext('PageFaultCount    %8d'), info.get('PageFaultCount', 0))
 
170
    trace.note('PrivateUsage      %8d KiB', info.get('PrivateUsage', 0) / 1024)
 
171
    trace.note('PageFaultCount    %8d', info.get('PageFaultCount', 0))
157
172
 
158
173
 
159
174
def get_console_size(defaultx=80, defaulty=25):
175
190
 
176
191
    if res:
177
192
        (bufx, bufy, curx, cury, wattr,
178
 
         left, top, right, bottom, maxx, maxy) = struct.unpack(
 
193
        left, top, right, bottom, maxx, maxy) = struct.unpack(
179
194
            "hhhhHhhhhhh", csbi.raw)
180
195
        sizex = right - left + 1
181
196
        sizey = bottom - top + 1
197
212
            pass
198
213
        else:
199
214
            buf = ctypes.create_unicode_buffer(MAX_PATH)
200
 
            if SHGetSpecialFolderPath(None, buf, csidl, 0):
 
215
            if SHGetSpecialFolderPath(None,buf,csidl,0):
201
216
                return buf.value
202
217
 
203
218
    global has_win32com_shell
227
242
    one that moves with the user as they logon to different machines, and
228
243
    a 'local' one that stays local to the machine.  This returns the 'roaming'
229
244
    directory, and thus is suitable for storing user-preferences, etc.
 
245
 
 
246
    Returned value can be unicode or plain string.
 
247
    To convert plain string to unicode use
 
248
    s.decode(osutils.get_user_encoding())
 
249
    (XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
230
250
    """
231
251
    appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
232
252
    if appdata:
233
253
        return appdata
234
 
    # Use APPDATA if defined, will return None if not
235
 
    return get_environ_unicode('APPDATA')
 
254
    # from env variable
 
255
    appdata = os.environ.get('APPDATA')
 
256
    if appdata:
 
257
        return appdata
 
258
    # if we fall to this point we on win98
 
259
    # at least try C:/WINDOWS/Application Data
 
260
    windir = os.environ.get('windir')
 
261
    if windir:
 
262
        appdata = os.path.join(windir, 'Application Data')
 
263
        if os.path.isdir(appdata):
 
264
            return appdata
 
265
    # did not find anything
 
266
    return None
236
267
 
237
268
 
238
269
def get_local_appdata_location():
244
275
    a 'local' one that stays local to the machine.  This returns the 'local'
245
276
    directory, and thus is suitable for caches, temp files and other things
246
277
    which don't need to move with the user.
 
278
 
 
279
    Returned value can be unicode or plain string.
 
280
    To convert plain string to unicode use
 
281
    s.decode(osutils.get_user_encoding())
 
282
    (XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
247
283
    """
248
284
    local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
249
285
    if local:
250
286
        return local
251
287
    # Vista supplies LOCALAPPDATA, but XP and earlier do not.
252
 
    local = get_environ_unicode('LOCALAPPDATA')
 
288
    local = os.environ.get('LOCALAPPDATA')
253
289
    if local:
254
290
        return local
255
291
    return get_appdata_location()
260
296
    Assume on win32 it's the <My Documents> folder.
261
297
    If location cannot be obtained return system drive root,
262
298
    i.e. C:\
 
299
 
 
300
    Returned value can be unicode or plain string.
 
301
    To convert plain string to unicode use
 
302
    s.decode(osutils.get_user_encoding())
263
303
    """
264
304
    home = _get_sh_special_folder_path(CSIDL_PERSONAL)
265
305
    if home:
266
306
        return home
267
 
    home = get_environ_unicode('HOME')
268
 
    if home is not None:
 
307
    # try for HOME env variable
 
308
    home = os.path.expanduser('~')
 
309
    if home != '~':
269
310
        return home
270
 
    homepath = get_environ_unicode('HOMEPATH')
271
 
    if homepath is not None:
272
 
        return os.path.join(get_environ_unicode('HOMEDIR', ''), home)
273
311
    # at least return windows root directory
274
 
    windir = get_environ_unicode('WINDIR')
 
312
    windir = os.environ.get('windir')
275
313
    if windir:
276
314
        return os.path.splitdrive(windir)[0] + '/'
277
315
    # otherwise C:\ is good enough for 98% users
278
 
    return u'C:/'
 
316
    return 'C:/'
279
317
 
280
318
 
281
319
def get_user_name():
282
320
    """Return user name as login name.
283
321
    If name cannot be obtained return None.
 
322
 
 
323
    Returned value can be unicode or plain string.
 
324
    To convert plain string to unicode use
 
325
    s.decode(osutils.get_user_encoding())
284
326
    """
285
327
    if has_ctypes:
286
328
        try:
287
329
            advapi32 = ctypes.windll.advapi32
288
 
            GetUserName = getattr(advapi32, 'GetUserName' + suffix)
 
330
            GetUserName = getattr(advapi32, 'GetUserName'+suffix)
289
331
        except AttributeError:
290
332
            pass
291
333
        else:
292
 
            buf = create_buffer(UNLEN + 1)
293
 
            n = ctypes.c_int(UNLEN + 1)
 
334
            buf = create_buffer(UNLEN+1)
 
335
            n = ctypes.c_int(UNLEN+1)
294
336
            if GetUserName(buf, ctypes.byref(n)):
295
 
                return extract_buffer(buf)
 
337
                return buf.value
296
338
    # otherwise try env variables
297
 
    return get_environ_unicode('USERNAME')
 
339
    return os.environ.get('USERNAME', None)
298
340
 
299
341
 
300
342
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
301
343
# computer or the cluster associated with the local computer."
302
344
_WIN32_ComputerNameDnsHostname = 1
303
345
 
304
 
 
305
346
def get_host_name():
306
347
    """Return host machine name.
307
348
    If name cannot be obtained return None.
308
349
 
309
 
    :return: A unicode string representing the host name.
 
350
    :return: A unicode string representing the host name. On win98, this may be
 
351
        a plain string as win32 api doesn't support unicode.
310
352
    """
311
353
    if has_win32api:
312
354
        try:
318
360
        try:
319
361
            kernel32 = ctypes.windll.kernel32
320
362
        except AttributeError:
321
 
            pass  # Missing the module we need
 
363
            pass # Missing the module we need
322
364
        else:
323
 
            buf = create_buffer(MAX_COMPUTERNAME_LENGTH + 1)
324
 
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH + 1)
 
365
            buf = create_buffer(MAX_COMPUTERNAME_LENGTH+1)
 
366
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
325
367
 
326
368
            # Try GetComputerNameEx which gives a proper Unicode hostname
327
 
            GetComputerNameEx = getattr(kernel32, 'GetComputerNameEx' + suffix,
 
369
            GetComputerNameEx = getattr(kernel32, 'GetComputerNameEx'+suffix,
328
370
                                        None)
329
371
            if (GetComputerNameEx is not None
330
372
                and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
331
373
                                      buf, ctypes.byref(n))):
332
 
                return extract_buffer(buf)
 
374
                return buf.value
333
375
 
334
376
            # Try GetComputerName in case GetComputerNameEx wasn't found
335
377
            # It returns the NETBIOS name, which isn't as good, but still ok.
336
378
            # The first GetComputerNameEx might have changed 'n', so reset it
337
 
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH + 1)
338
 
            GetComputerName = getattr(kernel32, 'GetComputerName' + suffix,
 
379
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
 
380
            GetComputerName = getattr(kernel32, 'GetComputerName'+suffix,
339
381
                                      None)
340
382
            if (GetComputerName is not None
341
 
                    and GetComputerName(buf, ctypes.byref(n))):
342
 
                return extract_buffer(buf)
343
 
    return get_environ_unicode('COMPUTERNAME')
 
383
                and GetComputerName(buf, ctypes.byref(n))):
 
384
                return buf.value
 
385
    # otherwise try env variables, which will be 'mbcs' encoded
 
386
    # on Windows (Python doesn't expose the native win32 unicode environment)
 
387
    # According to this:
 
388
    # http://msdn.microsoft.com/en-us/library/aa246807.aspx
 
389
    # environment variables should always be encoded in 'mbcs'.
 
390
    try:
 
391
        return os.environ['COMPUTERNAME'].decode("mbcs")
 
392
    except KeyError:
 
393
        return None
 
394
 
 
395
 
 
396
def _ensure_unicode(s):
 
397
    if s and type(s) != unicode:
 
398
        from bzrlib import osutils
 
399
        s = s.decode(osutils.get_user_encoding())
 
400
    return s
 
401
 
 
402
 
 
403
def get_appdata_location_unicode():
 
404
    return _ensure_unicode(get_appdata_location())
 
405
 
 
406
def get_home_location_unicode():
 
407
    return _ensure_unicode(get_home_location())
 
408
 
 
409
def get_user_name_unicode():
 
410
    return _ensure_unicode(get_user_name())
 
411
 
 
412
def get_host_name_unicode():
 
413
    return _ensure_unicode(get_host_name())
344
414
 
345
415
 
346
416
def _ensure_with_dir(path):
347
417
    if (not os.path.split(path)[0] or path.startswith(u'*')
348
 
            or path.startswith(u'?')):
 
418
        or path.startswith(u'?')):
349
419
        return u'./' + path, True
350
420
    else:
351
421
        return path, False
352
422
 
353
 
 
354
423
def _undo_ensure_with_dir(path, corrected):
355
424
    if corrected:
356
425
        return path[2:]
358
427
        return path
359
428
 
360
429
 
 
430
 
361
431
def glob_one(possible_glob):
362
432
    """Same as glob.glob().
363
433
 
387
457
    :param file_list: A list of filenames which may include shell globs.
388
458
    :return: An expanded list of filenames.
389
459
 
390
 
    Introduced in breezy 0.18.
 
460
    Introduced in bzrlib 0.18.
391
461
    """
392
462
    if not file_list:
393
463
        return []
398
468
 
399
469
 
400
470
def get_app_path(appname):
401
 
    r"""Look up in Windows registry for full path to application executable.
 
471
    """Look up in Windows registry for full path to application executable.
402
472
    Typically, applications create subkey with their basename
403
473
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
404
474
 
415
485
 
416
486
    try:
417
487
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
418
 
                               'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
419
 
                               basename)
 
488
            'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
 
489
            basename)
420
490
    except EnvironmentError:
421
491
        return appname
422
492
 
441
511
def set_file_attr_hidden(path):
442
512
    """Set file attributes to hidden if possible"""
443
513
    if has_win32file:
444
 
        SetFileAttributes = win32file.SetFileAttributesW
 
514
        if winver != 'Windows 98':
 
515
            SetFileAttributes = win32file.SetFileAttributesW
 
516
        else:
 
517
            SetFileAttributes = win32file.SetFileAttributes
445
518
        try:
446
519
            SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
447
 
        except pywintypes.error as e:
448
 
            from . import trace
 
520
        except pywintypes.error, e:
 
521
            from bzrlib import trace
449
522
            trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
450
523
 
451
524
 
452
 
def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
 
525
def _command_line_to_argv(command_line, single_quotes_allowed=False):
453
526
    """Convert a Unicode command line into a list of argv arguments.
454
527
 
455
528
    It performs wildcard expansion to make wildcards act closer to how they
462
535
                                  default.
463
536
    :return: A list of unicode strings.
464
537
    """
465
 
    # First, split the command line
466
 
    s = cmdline.Splitter(
467
 
        command_line, single_quotes_allowed=single_quotes_allowed)
468
 
 
469
 
    # Bug #587868 Now make sure that the length of s agrees with sys.argv
470
 
    # we do this by simply counting the number of arguments in each. The counts should
471
 
    # agree no matter what encoding sys.argv is in (AFAIK)
472
 
    # len(arguments) < len(sys.argv) should be an impossibility since python gets
473
 
    # args from the very same PEB as does GetCommandLineW
474
 
    arguments = list(s)
475
 
 
476
 
    # Now shorten the command line we get from GetCommandLineW to match sys.argv
477
 
    if len(arguments) < len(argv):
478
 
        raise AssertionError("Split command line can't be shorter than argv")
479
 
    arguments = arguments[len(arguments) - len(argv):]
480
 
 
481
 
    # Carry on to process globs (metachars) in the command line
482
 
    # expand globs if necessary
 
538
    s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
 
539
    # Now that we've split the content, expand globs if necessary
483
540
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
484
541
    #       '**/' style globs
485
542
    args = []
486
 
    for is_quoted, arg in arguments:
 
543
    for is_quoted, arg in s:
487
544
        if is_quoted or not glob.has_magic(arg):
488
545
            args.append(arg)
489
546
        else:
491
548
    return args
492
549
 
493
550
 
494
 
if has_ctypes:
 
551
if has_ctypes and winver != 'Windows 98':
495
552
    def get_unicode_argv():
496
553
        prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
497
554
        GetCommandLineW = prototype(("GetCommandLineW",
500
557
        if command_line is None:
501
558
            raise ctypes.WinError()
502
559
        # Skip the first argument, since we only care about parameters
503
 
        argv = _command_line_to_argv(command_line, sys.argv)[1:]
 
560
        argv = _command_line_to_argv(command_line)[1:]
 
561
        if getattr(sys, 'frozen', None) is None:
 
562
            # Invoked via 'python.exe' which takes the form:
 
563
            #   python.exe [PYTHON_OPTIONS] C:\Path\bzr [BZR_OPTIONS]
 
564
            # we need to get only BZR_OPTIONS part,
 
565
            # We already removed 'python.exe' so we remove everything up to and
 
566
            # including the first non-option ('-') argument.
 
567
            for idx in xrange(len(argv)):
 
568
                if argv[idx][:1] != '-':
 
569
                    break
 
570
            argv = argv[idx+1:]
504
571
        return argv
505
 
 
506
 
    def get_environ_unicode(key, default=None):
507
 
        """Get `key` from environment as unicode or `default` if unset
508
 
 
509
 
        The environment is natively unicode on modern windows versions but
510
 
        Python 2 only accesses it through the legacy bytestring api.
511
 
 
512
 
        Environmental variable names are case insenstive on Windows.
513
 
 
514
 
        A large enough buffer will be allocated to retrieve the value, though
515
 
        it may take two calls to the underlying library function.
516
 
 
517
 
        This needs ctypes because pywin32 does not expose the wide version.
518
 
        """
519
 
        cfunc = getattr(get_environ_unicode, "_c_function", None)
520
 
        if cfunc is None:
521
 
            from ctypes.wintypes import DWORD, LPCWSTR, LPWSTR
522
 
            cfunc = ctypes.WINFUNCTYPE(DWORD, LPCWSTR, LPWSTR, DWORD)(
523
 
                ("GetEnvironmentVariableW", ctypes.windll.kernel32))
524
 
            get_environ_unicode._c_function = cfunc
525
 
        buffer_size = 256  # heuristic, 256 characters often enough
526
 
        while True:
527
 
            buffer = ctypes.create_unicode_buffer(buffer_size)
528
 
            length = cfunc(key, buffer, buffer_size)
529
 
            if not length:
530
 
                code = ctypes.GetLastError()
531
 
                if code == 203:  # ERROR_ENVVAR_NOT_FOUND
532
 
                    return default
533
 
                raise ctypes.WinError(code)
534
 
            if buffer_size > length:
535
 
                return buffer[:length]
536
 
            buffer_size = length
537
 
 
538
 
 
539
 
if has_win32api:
540
 
    def _pywin32_is_local_pid_dead(pid):
541
 
        """True if pid doesn't correspond to live process on this machine"""
542
 
        try:
543
 
            handle = win32api.OpenProcess(1, False, pid)  # PROCESS_TERMINATE
544
 
        except pywintypes.error as e:
545
 
            if e[0] == 5:  # ERROR_ACCESS_DENIED
546
 
                # Probably something alive we're not allowed to kill
547
 
                return False
548
 
            elif e[0] == 87:  # ERROR_INVALID_PARAMETER
549
 
                return True
550
 
            raise
551
 
        handle.close()
552
 
        return False
553
 
    is_local_pid_dead = _pywin32_is_local_pid_dead
554
 
elif has_ctypes and sys.platform == 'win32':
555
 
    from ctypes.wintypes import BOOL, DWORD, HANDLE
556
 
    _kernel32 = ctypes.windll.kernel32
557
 
    _CloseHandle = ctypes.WINFUNCTYPE(BOOL, HANDLE)(
558
 
        ("CloseHandle", _kernel32))
559
 
    _OpenProcess = ctypes.WINFUNCTYPE(HANDLE, DWORD, BOOL, DWORD)(
560
 
        ("OpenProcess", _kernel32))
561
 
 
562
 
    def _ctypes_is_local_pid_dead(pid):
563
 
        """True if pid doesn't correspond to live process on this machine"""
564
 
        handle = _OpenProcess(1, False, pid)  # PROCESS_TERMINATE
565
 
        if not handle:
566
 
            errorcode = ctypes.GetLastError()
567
 
            if errorcode == 5:  # ERROR_ACCESS_DENIED
568
 
                # Probably something alive we're not allowed to kill
569
 
                return False
570
 
            elif errorcode == 87:  # ERROR_INVALID_PARAMETER
571
 
                return True
572
 
            raise ctypes.WinError(errorcode)
573
 
        _CloseHandle(handle)
574
 
        return False
575
 
    is_local_pid_dead = _ctypes_is_local_pid_dead
576
 
 
577
 
 
578
 
def _is_pywintypes_error(evalue):
579
 
    """True if exception instance is an error from pywin32"""
580
 
    if has_pywintypes and isinstance(evalue, pywintypes.error):
581
 
        return True
582
 
    return False
 
572
else:
 
573
    get_unicode_argv = None