/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 breezy/win32utils.py

  • Committer: Jelmer Vernooij
  • Date: 2020-02-18 01:57:45 UTC
  • mto: This revision was merged to the branch mainline in revision 7493.
  • Revision ID: jelmer@jelmer.uk-20200218015745-q2ss9tsk74h4nh61
drop use of future.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/win32utils.py
24
24
import struct
25
25
import sys
26
26
 
27
 
from bzrlib import cmdline
 
27
from breezy import (
 
28
    cmdline,
 
29
    )
 
30
from breezy.i18n import gettext
28
31
 
29
 
# Windows version
 
32
has_ctypes_win32 = False
30
33
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
 
 
55
 
 
56
 
# We can cope without it; use a separate variable to help pyflakes
57
 
try:
58
 
    import ctypes
59
 
    has_ctypes = True
60
 
except ImportError:
61
 
    has_ctypes = False
62
 
else:
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'
69
 
try:
70
 
    import win32file
71
 
    import pywintypes
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
80
 
 
81
 
# pulling in win32com.shell is a bit of overhead, and normally we don't need
82
 
# it as ctypes is preferred and common.  lazy_imports and "optional"
83
 
# modules don't work well, so we do our own lazy thing...
84
 
has_win32com_shell = None # Set to True or False once we know for sure...
 
34
    try:
 
35
        import ctypes
 
36
    except ImportError:
 
37
        has_ctypes_win32 = False
 
38
 
85
39
 
86
40
# Special Win32 API constants
87
41
# Handles of std streams
91
45
 
92
46
# CSIDL constants (from MSDN 2003)
93
47
CSIDL_APPDATA = 0x001A      # Application Data folder
94
 
CSIDL_LOCAL_APPDATA = 0x001c# <user name>\Local Settings\Application Data (non roaming)
 
48
# <user name>\Local Settings\Application Data (non roaming)
 
49
CSIDL_LOCAL_APPDATA = 0x001c
95
50
CSIDL_PERSONAL = 0x0005     # My Documents folder
96
51
 
97
52
# from winapi C headers
106
61
 
107
62
def debug_memory_win32api(message='', short=True):
108
63
    """Use trace.note() to dump the running memory info."""
109
 
    from bzrlib import trace
110
 
    if has_ctypes:
 
64
    from breezy import trace
 
65
    if has_ctypes_win32:
111
66
        class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
112
67
            """Used by GetProcessMemoryInfo"""
113
68
            _fields_ = [('cb', ctypes.c_ulong),
121
76
                        ('PagefileUsage', ctypes.c_size_t),
122
77
                        ('PeakPagefileUsage', ctypes.c_size_t),
123
78
                        ('PrivateUsage', ctypes.c_size_t),
124
 
                       ]
 
79
                        ]
125
80
        cur_process = ctypes.windll.kernel32.GetCurrentProcess()
126
81
        mem_struct = PROCESS_MEMORY_COUNTERS_EX()
127
 
        ret = ctypes.windll.psapi.GetProcessMemoryInfo(cur_process,
128
 
            ctypes.byref(mem_struct),
129
 
            ctypes.sizeof(mem_struct))
 
82
        ret = ctypes.windll.psapi.GetProcessMemoryInfo(
 
83
            cur_process, ctypes.byref(mem_struct), ctypes.sizeof(mem_struct))
130
84
        if not ret:
131
 
            trace.note('Failed to GetProcessMemoryInfo()')
 
85
            trace.note(gettext('Failed to GetProcessMemoryInfo()'))
132
86
            return
133
87
        info = {'PageFaultCount': mem_struct.PageFaultCount,
134
88
                'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
141
95
                'PagefileUsage': mem_struct.PagefileUsage,
142
96
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
143
97
                'PrivateUsage': mem_struct.PrivateUsage,
144
 
               }
145
 
    elif has_win32api:
146
 
        import win32process
147
 
        # win32process does not return PrivateUsage, because it doesn't use
148
 
        # PROCESS_MEMORY_COUNTERS_EX (it uses the one without _EX).
149
 
        proc = win32process.GetCurrentProcess()
150
 
        info = win32process.GetProcessMemoryInfo(proc)
 
98
                }
151
99
    else:
152
 
        trace.note('Cannot debug memory on win32 without ctypes'
153
 
                   ' or win32process')
 
100
        trace.note(gettext('Cannot debug memory on win32 without ctypes'
 
101
                           ' or win32process'))
154
102
        return
155
103
    if short:
156
104
        # using base-2 units (see HACKING.txt).
157
 
        trace.note('WorkingSize %7dKiB'
158
 
                   '\tPeakWorking %7dKiB\t%s',
 
105
        trace.note(gettext('WorkingSize {0:>7}KiB'
 
106
                           '\tPeakWorking {1:>7}KiB\t{2}').format(
159
107
                   info['WorkingSetSize'] / 1024,
160
108
                   info['PeakWorkingSetSize'] / 1024,
161
 
                   message)
 
109
                   message))
162
110
        return
163
111
    if message:
164
112
        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',
 
113
    trace.note(gettext('WorkingSize       %8d KiB'),
 
114
               info['WorkingSetSize'] / 1024)
 
115
    trace.note(gettext('PeakWorking       %8d KiB'),
 
116
               info['PeakWorkingSetSize'] / 1024)
 
117
    trace.note(gettext('PagefileUsage     %8d KiB'),
 
118
               info.get('PagefileUsage', 0) / 1024)
 
119
    trace.note(gettext('PeakPagefileUsage %8d KiB'),
169
120
               info.get('PeakPagefileUsage', 0) / 1024)
170
 
    trace.note('PrivateUsage      %8d KiB', info.get('PrivateUsage', 0) / 1024)
171
 
    trace.note('PageFaultCount    %8d', info.get('PageFaultCount', 0))
 
121
    trace.note(gettext('PrivateUsage      %8d KiB'),
 
122
               info.get('PrivateUsage', 0) / 1024)
 
123
    trace.note(gettext('PageFaultCount    %8d'), info.get('PageFaultCount', 0))
172
124
 
173
125
 
174
126
def get_console_size(defaultx=80, defaulty=25):
178
130
    console window and return tuple (sizex, sizey) if success,
179
131
    or default size (defaultx, defaulty) otherwise.
180
132
    """
181
 
    if not has_ctypes:
 
133
    if not has_ctypes_win32:
182
134
        # no ctypes is found
183
135
        return (defaultx, defaulty)
184
136
 
190
142
 
191
143
    if res:
192
144
        (bufx, bufy, curx, cury, wattr,
193
 
        left, top, right, bottom, maxx, maxy) = struct.unpack(
 
145
         left, top, right, bottom, maxx, maxy) = struct.unpack(
194
146
            "hhhhHhhhhhh", csbi.raw)
195
147
        sizex = right - left + 1
196
148
        sizey = bottom - top + 1
204
156
 
205
157
    Result is always unicode (or None).
206
158
    """
207
 
    if has_ctypes:
 
159
    if has_ctypes_win32:
208
160
        try:
209
161
            SHGetSpecialFolderPath = \
210
162
                ctypes.windll.shell32.SHGetSpecialFolderPathW
212
164
            pass
213
165
        else:
214
166
            buf = ctypes.create_unicode_buffer(MAX_PATH)
215
 
            if SHGetSpecialFolderPath(None,buf,csidl,0):
 
167
            if SHGetSpecialFolderPath(None, buf, csidl, 0):
216
168
                return buf.value
217
 
 
218
 
    global has_win32com_shell
219
 
    if has_win32com_shell is None:
220
 
        try:
221
 
            from win32com.shell import shell
222
 
            has_win32com_shell = True
223
 
        except ImportError:
224
 
            has_win32com_shell = False
225
 
    if has_win32com_shell:
226
 
        # still need to bind the name locally, but this is fast.
227
 
        from win32com.shell import shell
228
 
        try:
229
 
            return shell.SHGetSpecialFolderPath(0, csidl, 0)
230
 
        except shell.error:
231
 
            # possibly E_NOTIMPL meaning we can't load the function pointer,
232
 
            # or E_FAIL meaning the function failed - regardless, just ignore it
233
 
            pass
234
169
    return None
235
170
 
236
171
 
242
177
    one that moves with the user as they logon to different machines, and
243
178
    a 'local' one that stays local to the machine.  This returns the 'roaming'
244
179
    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')
250
180
    """
251
181
    appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
252
182
    if appdata:
253
183
        return 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
 
184
    # Use APPDATA if defined, will return None if not
 
185
    return get_environ_unicode('APPDATA')
267
186
 
268
187
 
269
188
def get_local_appdata_location():
275
194
    a 'local' one that stays local to the machine.  This returns the 'local'
276
195
    directory, and thus is suitable for caches, temp files and other things
277
196
    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')
283
197
    """
284
198
    local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
285
199
    if local:
286
200
        return local
287
201
    # Vista supplies LOCALAPPDATA, but XP and earlier do not.
288
 
    local = os.environ.get('LOCALAPPDATA')
 
202
    local = get_environ_unicode('LOCALAPPDATA')
289
203
    if local:
290
204
        return local
291
205
    return get_appdata_location()
296
210
    Assume on win32 it's the <My Documents> folder.
297
211
    If location cannot be obtained return system drive root,
298
212
    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())
303
213
    """
304
214
    home = _get_sh_special_folder_path(CSIDL_PERSONAL)
305
215
    if home:
306
216
        return home
307
 
    # try for HOME env variable
308
 
    home = os.path.expanduser('~')
309
 
    if home != '~':
 
217
    home = get_environ_unicode('HOME')
 
218
    if home is not None:
310
219
        return home
 
220
    homepath = get_environ_unicode('HOMEPATH')
 
221
    if homepath is not None:
 
222
        return os.path.join(get_environ_unicode('HOMEDIR', ''), home)
311
223
    # at least return windows root directory
312
 
    windir = os.environ.get('windir')
 
224
    windir = get_environ_unicode('WINDIR')
313
225
    if windir:
314
226
        return os.path.splitdrive(windir)[0] + '/'
315
227
    # otherwise C:\ is good enough for 98% users
316
 
    return 'C:/'
 
228
    return u'C:/'
317
229
 
318
230
 
319
231
def get_user_name():
320
232
    """Return user name as login name.
321
233
    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())
326
234
    """
327
 
    if has_ctypes:
 
235
    if has_ctypes_win32:
328
236
        try:
329
237
            advapi32 = ctypes.windll.advapi32
330
 
            GetUserName = getattr(advapi32, 'GetUserName'+suffix)
 
238
            GetUserName = getattr(advapi32, 'GetUserNameW')
331
239
        except AttributeError:
332
240
            pass
333
241
        else:
334
 
            buf = create_buffer(UNLEN+1)
335
 
            n = ctypes.c_int(UNLEN+1)
 
242
            buf = ctypes.create_unicode_buffer(UNLEN + 1)
 
243
            n = ctypes.c_int(UNLEN + 1)
336
244
            if GetUserName(buf, ctypes.byref(n)):
337
245
                return buf.value
338
246
    # otherwise try env variables
339
 
    return os.environ.get('USERNAME', None)
 
247
    return get_environ_unicode('USERNAME')
340
248
 
341
249
 
342
250
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
343
251
# computer or the cluster associated with the local computer."
344
252
_WIN32_ComputerNameDnsHostname = 1
345
253
 
 
254
 
346
255
def get_host_name():
347
256
    """Return host machine name.
348
257
    If name cannot be obtained return None.
349
258
 
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.
 
259
    :return: A unicode string representing the host name.
352
260
    """
353
 
    if has_win32api:
354
 
        try:
355
 
            return win32api.GetComputerNameEx(_WIN32_ComputerNameDnsHostname)
356
 
        except (NotImplementedError, win32api.error):
357
 
            # NotImplemented will happen on win9x...
358
 
            pass
359
 
    if has_ctypes:
 
261
    if has_ctypes_win32:
360
262
        try:
361
263
            kernel32 = ctypes.windll.kernel32
362
264
        except AttributeError:
363
 
            pass # Missing the module we need
 
265
            pass  # Missing the module we need
364
266
        else:
365
 
            buf = create_buffer(MAX_COMPUTERNAME_LENGTH+1)
366
 
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
 
267
            buf = ctypes.create_unicode_buffer(MAX_COMPUTERNAME_LENGTH + 1)
 
268
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH + 1)
367
269
 
368
270
            # Try GetComputerNameEx which gives a proper Unicode hostname
369
 
            GetComputerNameEx = getattr(kernel32, 'GetComputerNameEx'+suffix,
370
 
                                        None)
 
271
            GetComputerNameEx = getattr(kernel32, 'GetComputerNameExW', None)
371
272
            if (GetComputerNameEx is not None
372
273
                and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
373
274
                                      buf, ctypes.byref(n))):
374
275
                return buf.value
375
 
 
376
 
            # Try GetComputerName in case GetComputerNameEx wasn't found
377
 
            # It returns the NETBIOS name, which isn't as good, but still ok.
378
 
            # The first GetComputerNameEx might have changed 'n', so reset it
379
 
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
380
 
            GetComputerName = getattr(kernel32, 'GetComputerName'+suffix,
381
 
                                      None)
382
 
            if (GetComputerName is not None
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())
 
276
    return get_environ_unicode('COMPUTERNAME')
414
277
 
415
278
 
416
279
def _ensure_with_dir(path):
417
280
    if (not os.path.split(path)[0] or path.startswith(u'*')
418
 
        or path.startswith(u'?')):
 
281
            or path.startswith(u'?')):
419
282
        return u'./' + path, True
420
283
    else:
421
284
        return path, False
422
285
 
 
286
 
423
287
def _undo_ensure_with_dir(path, corrected):
424
288
    if corrected:
425
289
        return path[2:]
427
291
        return path
428
292
 
429
293
 
430
 
 
431
294
def glob_one(possible_glob):
432
295
    """Same as glob.glob().
433
296
 
457
320
    :param file_list: A list of filenames which may include shell globs.
458
321
    :return: An expanded list of filenames.
459
322
 
460
 
    Introduced in bzrlib 0.18.
 
323
    Introduced in breezy 0.18.
461
324
    """
462
325
    if not file_list:
463
326
        return []
468
331
 
469
332
 
470
333
def get_app_path(appname):
471
 
    """Look up in Windows registry for full path to application executable.
 
334
    r"""Look up in Windows registry for full path to application executable.
472
335
    Typically, applications create subkey with their basename
473
336
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
474
337
 
485
348
 
486
349
    try:
487
350
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
488
 
            'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
489
 
            basename)
 
351
                               'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
 
352
                               basename)
490
353
    except EnvironmentError:
491
354
        return appname
492
355
 
510
373
 
511
374
def set_file_attr_hidden(path):
512
375
    """Set file attributes to hidden if possible"""
513
 
    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, single_quotes_allowed=False):
 
376
    if not has_ctypes_win32:
 
377
        return
 
378
    from ctypes.wintypes import BOOL, DWORD, LPCWSTR
 
379
    _kernel32 = ctypes.windll.kernel32
 
380
    # <https://docs.microsoft.com/windows/desktop/api/fileapi/nf-fileapi-setfileattributesw>
 
381
    _SetFileAttributesW = ctypes.WINFUNCTYPE(BOOL, LPCWSTR, DWORD)(
 
382
        ("SetFileAttributesW", _kernel32))
 
383
    FILE_ATTRIBUTE_HIDDEN = 2
 
384
    if not SetFileAttributes(path, FILE_ATTRIBUTE_HIDDEN):
 
385
        e = ctypes.WinError()
 
386
        from . import trace
 
387
        trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
 
388
 
 
389
 
 
390
def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
526
391
    """Convert a Unicode command line into a list of argv arguments.
527
392
 
528
393
    It performs wildcard expansion to make wildcards act closer to how they
535
400
                                  default.
536
401
    :return: A list of unicode strings.
537
402
    """
538
 
    s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
539
 
    # Now that we've split the content, expand globs if necessary
 
403
    # First, split the command line
 
404
    s = cmdline.Splitter(
 
405
        command_line, single_quotes_allowed=single_quotes_allowed)
 
406
 
 
407
    # Bug #587868 Now make sure that the length of s agrees with sys.argv
 
408
    # we do this by simply counting the number of arguments in each. The counts should
 
409
    # agree no matter what encoding sys.argv is in (AFAIK)
 
410
    # len(arguments) < len(sys.argv) should be an impossibility since python gets
 
411
    # args from the very same PEB as does GetCommandLineW
 
412
    arguments = list(s)
 
413
 
 
414
    # Now shorten the command line we get from GetCommandLineW to match sys.argv
 
415
    if len(arguments) < len(argv):
 
416
        raise AssertionError("Split command line can't be shorter than argv")
 
417
    arguments = arguments[len(arguments) - len(argv):]
 
418
 
 
419
    # Carry on to process globs (metachars) in the command line
 
420
    # expand globs if necessary
540
421
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
541
422
    #       '**/' style globs
542
423
    args = []
543
 
    for is_quoted, arg in s:
 
424
    for is_quoted, arg in arguments:
544
425
        if is_quoted or not glob.has_magic(arg):
545
426
            args.append(arg)
546
427
        else:
548
429
    return args
549
430
 
550
431
 
551
 
if has_ctypes and winver != 'Windows 98':
 
432
if has_ctypes_win32:
552
433
    def get_unicode_argv():
553
434
        prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
554
435
        GetCommandLineW = prototype(("GetCommandLineW",
557
438
        if command_line is None:
558
439
            raise ctypes.WinError()
559
440
        # Skip the first argument, since we only care about parameters
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:]
 
441
        argv = _command_line_to_argv(command_line, sys.argv)[1:]
571
442
        return argv
572
 
else:
573
 
    get_unicode_argv = None
 
443
 
 
444
    def get_environ_unicode(key, default=None):
 
445
        """Get `key` from environment as unicode or `default` if unset
 
446
 
 
447
        The environment is natively unicode on modern windows versions but
 
448
        Python 2 only accesses it through the legacy bytestring api.
 
449
 
 
450
        Environmental variable names are case insenstive on Windows.
 
451
 
 
452
        A large enough buffer will be allocated to retrieve the value, though
 
453
        it may take two calls to the underlying library function.
 
454
        """
 
455
        cfunc = getattr(get_environ_unicode, "_c_function", None)
 
456
        if cfunc is None:
 
457
            from ctypes.wintypes import DWORD, LPCWSTR, LPWSTR
 
458
            cfunc = ctypes.WINFUNCTYPE(DWORD, LPCWSTR, LPWSTR, DWORD)(
 
459
                ("GetEnvironmentVariableW", ctypes.windll.kernel32))
 
460
            get_environ_unicode._c_function = cfunc
 
461
        buffer_size = 256  # heuristic, 256 characters often enough
 
462
        while True:
 
463
            buf = ctypes.create_unicode_buffer(buffer_size)
 
464
            length = cfunc(key, buf, buffer_size)
 
465
            if not length:
 
466
                code = ctypes.GetLastError()
 
467
                if code == 203:  # ERROR_ENVVAR_NOT_FOUND
 
468
                    return default
 
469
                raise ctypes.WinError(code)
 
470
            if buffer_size > length:
 
471
                return buf[:length]
 
472
            buffer_size = length
 
473
 
 
474
 
 
475
if has_ctypes_win32:
 
476
    from ctypes.wintypes import BOOL, DWORD, HANDLE
 
477
    _kernel32 = ctypes.windll.kernel32
 
478
    _CloseHandle = ctypes.WINFUNCTYPE(BOOL, HANDLE)(
 
479
        ("CloseHandle", _kernel32))
 
480
    _OpenProcess = ctypes.WINFUNCTYPE(HANDLE, DWORD, BOOL, DWORD)(
 
481
        ("OpenProcess", _kernel32))
 
482
 
 
483
    def _ctypes_is_local_pid_dead(pid):
 
484
        """True if pid doesn't correspond to live process on this machine"""
 
485
        handle = _OpenProcess(1, False, pid)  # PROCESS_TERMINATE
 
486
        if not handle:
 
487
            errorcode = ctypes.GetLastError()
 
488
            if errorcode == 5:  # ERROR_ACCESS_DENIED
 
489
                # Probably something alive we're not allowed to kill
 
490
                return False
 
491
            elif errorcode == 87:  # ERROR_INVALID_PARAMETER
 
492
                return True
 
493
            raise ctypes.WinError(errorcode)
 
494
        _CloseHandle(handle)
 
495
        return False
 
496
 
 
497
    is_local_pid_dead = _ctypes_is_local_pid_dead