/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: John Arbash Meinel
  • Date: 2010-01-25 10:18:24 UTC
  • mto: This revision was merged to the branch mainline in revision 4986.
  • Revision ID: john@arbash-meinel.com-20100125101824-qbamf96fz199iro9
we need to install the latest testtools as well

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 breezy import (
31
 
    cmdline,
32
 
    )
33
 
from breezy.i18n import gettext
 
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"
87
106
 
88
107
def debug_memory_win32api(message='', short=True):
89
108
    """Use trace.note() to dump the running memory info."""
90
 
    from breezy import trace
 
109
    from bzrlib import trace
91
110
    if has_ctypes:
92
111
        class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
93
112
            """Used by GetProcessMemoryInfo"""
109
128
            ctypes.byref(mem_struct),
110
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,
116
135
                'WorkingSetSize': mem_struct.WorkingSetSize,
117
136
                'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
118
137
                'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
119
 
                'QuotaPeakNonPagedPoolUsage':
120
 
                    mem_struct.QuotaPeakNonPagedPoolUsage,
 
138
                'QuotaPeakNonPagedPoolUsage': mem_struct.QuotaPeakNonPagedPoolUsage,
121
139
                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
122
140
                'PagefileUsage': mem_struct.PagefileUsage,
123
141
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
130
148
        proc = win32process.GetCurrentProcess()
131
149
        info = win32process.GetProcessMemoryInfo(proc)
132
150
    else:
133
 
        trace.note(gettext('Cannot debug memory on win32 without ctypes'
134
 
                   ' or win32process'))
 
151
        trace.note('Cannot debug memory on win32 without ctypes'
 
152
                   ' or win32process')
135
153
        return
136
154
    if short:
137
 
        # using base-2 units (see HACKING.txt).
138
 
        trace.note(gettext('WorkingSize {0:>7}KiB'
139
 
                   '\tPeakWorking {1:>7}KiB\t{2}').format(
 
155
        trace.note('WorkingSize %7dKB'
 
156
                   '\tPeakWorking %7dKB\t%s',
140
157
                   info['WorkingSetSize'] / 1024,
141
158
                   info['PeakWorkingSetSize'] / 1024,
142
 
                   message))
 
159
                   message)
143
160
        return
144
161
    if message:
145
162
        trace.note('%s', message)
146
 
    trace.note(gettext('WorkingSize       %8d KiB'), info['WorkingSetSize'] / 1024)
147
 
    trace.note(gettext('PeakWorking       %8d KiB'), info['PeakWorkingSetSize'] / 1024)
148
 
    trace.note(gettext('PagefileUsage     %8d KiB'), info.get('PagefileUsage', 0) / 1024)
149
 
    trace.note(gettext('PeakPagefileUsage %8d KiB'),
150
 
               info.get('PeakPagefileUsage', 0) / 1024)
151
 
    trace.note(gettext('PrivateUsage      %8d KiB'), info.get('PrivateUsage', 0) / 1024)
152
 
    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))
153
169
 
154
170
 
155
171
def get_console_size(defaultx=80, defaulty=25):
171
187
 
172
188
    if res:
173
189
        (bufx, bufy, curx, cury, wattr,
174
 
        left, top, right, bottom, maxx, maxy) = struct.unpack(
175
 
            "hhhhHhhhhhh", csbi.raw)
 
190
        left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
176
191
        sizex = right - left + 1
177
192
        sizey = bottom - top + 1
178
193
        return (sizex, sizey)
193
208
            pass
194
209
        else:
195
210
            buf = ctypes.create_unicode_buffer(MAX_PATH)
196
 
            if SHGetSpecialFolderPath(None, buf, csidl, 0):
 
211
            if SHGetSpecialFolderPath(None,buf,csidl,0):
197
212
                return buf.value
198
213
 
199
214
    global has_win32com_shell
223
238
    one that moves with the user as they logon to different machines, and
224
239
    a 'local' one that stays local to the machine.  This returns the 'roaming'
225
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')
226
246
    """
227
247
    appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
228
248
    if appdata:
229
249
        return appdata
230
 
    # Use APPDATA if defined, will return None if not
231
 
    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
232
263
 
233
264
 
234
265
def get_local_appdata_location():
240
271
    a 'local' one that stays local to the machine.  This returns the 'local'
241
272
    directory, and thus is suitable for caches, temp files and other things
242
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')
243
279
    """
244
280
    local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
245
281
    if local:
246
282
        return local
247
283
    # Vista supplies LOCALAPPDATA, but XP and earlier do not.
248
 
    local = get_environ_unicode('LOCALAPPDATA')
 
284
    local = os.environ.get('LOCALAPPDATA')
249
285
    if local:
250
286
        return local
251
287
    return get_appdata_location()
256
292
    Assume on win32 it's the <My Documents> folder.
257
293
    If location cannot be obtained return system drive root,
258
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())
259
299
    """
260
300
    home = _get_sh_special_folder_path(CSIDL_PERSONAL)
261
301
    if home:
262
302
        return home
263
 
    home = get_environ_unicode('HOME')
264
 
    if home is not None:
 
303
    # try for HOME env variable
 
304
    home = os.path.expanduser('~')
 
305
    if home != '~':
265
306
        return home
266
 
    homepath = get_environ_unicode('HOMEPATH')
267
 
    if homepath is not None:
268
 
        return os.path.join(get_environ_unicode('HOMEDIR', ''), home)
269
307
    # at least return windows root directory
270
 
    windir = get_environ_unicode('WINDIR')
 
308
    windir = os.environ.get('windir')
271
309
    if windir:
272
310
        return os.path.splitdrive(windir)[0] + '/'
273
311
    # otherwise C:\ is good enough for 98% users
274
 
    return u'C:/'
 
312
    return 'C:/'
275
313
 
276
314
 
277
315
def get_user_name():
278
316
    """Return user name as login name.
279
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())
280
322
    """
281
323
    if has_ctypes:
282
324
        try:
288
330
            buf = create_buffer(UNLEN+1)
289
331
            n = ctypes.c_int(UNLEN+1)
290
332
            if GetUserName(buf, ctypes.byref(n)):
291
 
                return extract_buffer(buf)
 
333
                return buf.value
292
334
    # otherwise try env variables
293
 
    return get_environ_unicode('USERNAME')
 
335
    return os.environ.get('USERNAME', None)
294
336
 
295
337
 
296
338
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
301
343
    """Return host machine name.
302
344
    If name cannot be obtained return None.
303
345
 
304
 
    :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.
305
348
    """
306
349
    if has_win32api:
307
350
        try:
324
367
            if (GetComputerNameEx is not None
325
368
                and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
326
369
                                      buf, ctypes.byref(n))):
327
 
                return extract_buffer(buf)
 
370
                return buf.value
328
371
 
329
372
            # Try GetComputerName in case GetComputerNameEx wasn't found
330
373
            # It returns the NETBIOS name, which isn't as good, but still ok.
334
377
                                      None)
335
378
            if (GetComputerName is not None
336
379
                and GetComputerName(buf, ctypes.byref(n))):
337
 
                return extract_buffer(buf)
338
 
    return get_environ_unicode('COMPUTERNAME')
 
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
 
 
392
def _ensure_unicode(s):
 
393
    if s and type(s) != unicode:
 
394
        from bzrlib import osutils
 
395
        s = s.decode(osutils.get_user_encoding())
 
396
    return s
 
397
 
 
398
 
 
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())
339
410
 
340
411
 
341
412
def _ensure_with_dir(path):
342
 
    if (not os.path.split(path)[0] or path.startswith(u'*')
343
 
        or path.startswith(u'?')):
 
413
    if not os.path.split(path)[0] or path.startswith(u'*') or path.startswith(u'?'):
344
414
        return u'./' + path, True
345
415
    else:
346
416
        return path, False
352
422
        return path
353
423
 
354
424
 
 
425
 
355
426
def glob_one(possible_glob):
356
427
    """Same as glob.glob().
357
428
 
381
452
    :param file_list: A list of filenames which may include shell globs.
382
453
    :return: An expanded list of filenames.
383
454
 
384
 
    Introduced in breezy 0.18.
 
455
    Introduced in bzrlib 0.18.
385
456
    """
386
457
    if not file_list:
387
458
        return []
392
463
 
393
464
 
394
465
def get_app_path(appname):
395
 
    r"""Look up in Windows registry for full path to application executable.
 
466
    """Look up in Windows registry for full path to application executable.
396
467
    Typically, applications create subkey with their basename
397
468
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
398
469
 
435
506
def set_file_attr_hidden(path):
436
507
    """Set file attributes to hidden if possible"""
437
508
    if has_win32file:
438
 
        SetFileAttributes = win32file.SetFileAttributesW
 
509
        if winver != 'Windows 98':
 
510
            SetFileAttributes = win32file.SetFileAttributesW
 
511
        else:
 
512
            SetFileAttributes = win32file.SetFileAttributes
439
513
        try:
440
514
            SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
441
 
        except pywintypes.error as e:
442
 
            from . import trace
 
515
        except pywintypes.error, e:
 
516
            from bzrlib import trace
443
517
            trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
444
518
 
445
519
 
446
 
def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
447
 
    """Convert a Unicode command line into a list of argv arguments.
448
 
 
449
 
    It performs wildcard expansion to make wildcards act closer to how they
450
 
    work in posix shells, versus how they work by default on Windows. Quoted
451
 
    arguments are left untouched.
452
 
 
453
 
    :param command_line: The unicode string to split into an arg list.
454
 
    :param single_quotes_allowed: Whether single quotes are accepted as quoting
455
 
                                  characters like double quotes. False by
456
 
                                  default.
457
 
    :return: A list of unicode strings.
458
 
    """
459
 
    # First, split the command line
460
 
    s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
461
 
    
462
 
    # Bug #587868 Now make sure that the length of s agrees with sys.argv 
463
 
    # we do this by simply counting the number of arguments in each. The counts should 
464
 
    # agree no matter what encoding sys.argv is in (AFAIK) 
465
 
    # len(arguments) < len(sys.argv) should be an impossibility since python gets 
466
 
    # args from the very same PEB as does GetCommandLineW
467
 
    arguments = list(s)
468
 
    
469
 
    # Now shorten the command line we get from GetCommandLineW to match sys.argv
470
 
    if len(arguments) < len(argv):
471
 
        raise AssertionError("Split command line can't be shorter than argv")
472
 
    arguments = arguments[len(arguments) - len(argv):]
473
 
    
474
 
    # Carry on to process globs (metachars) in the command line
475
 
    # 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
476
626
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
477
627
    #       '**/' style globs
478
628
    args = []
479
 
    for is_quoted, arg in arguments:
 
629
    for is_quoted, arg in s:
480
630
        if is_quoted or not glob.has_magic(arg):
481
631
            args.append(arg)
482
632
        else:
484
634
    return args
485
635
 
486
636
 
487
 
if has_ctypes:
 
637
if has_ctypes and winver != 'Windows 98':
488
638
    def get_unicode_argv():
489
 
        prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
490
 
        GetCommandLineW = prototype(("GetCommandLineW",
491
 
                                     ctypes.windll.kernel32))
492
 
        command_line = GetCommandLineW()
493
 
        if command_line is None:
494
 
            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()
495
647
        # Skip the first argument, since we only care about parameters
496
 
        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:]
497
659
        return argv
498
 
 
499
 
 
500
 
    def get_environ_unicode(key, default=None):
501
 
        """Get `key` from environment as unicode or `default` if unset
502
 
 
503
 
        The environment is natively unicode on modern windows versions but
504
 
        Python 2 only accesses it through the legacy bytestring api.
505
 
 
506
 
        Environmental variable names are case insenstive on Windows.
507
 
 
508
 
        A large enough buffer will be allocated to retrieve the value, though
509
 
        it may take two calls to the underlying library function.
510
 
 
511
 
        This needs ctypes because pywin32 does not expose the wide version.
512
 
        """
513
 
        cfunc = getattr(get_environ_unicode, "_c_function", None)
514
 
        if cfunc is None:
515
 
            from ctypes.wintypes import DWORD, LPCWSTR, LPWSTR
516
 
            cfunc = ctypes.WINFUNCTYPE(DWORD, LPCWSTR, LPWSTR, DWORD)(
517
 
                ("GetEnvironmentVariableW", ctypes.windll.kernel32))
518
 
            get_environ_unicode._c_function = cfunc
519
 
        buffer_size = 256 # heuristic, 256 characters often enough
520
 
        while True:
521
 
            buffer = ctypes.create_unicode_buffer(buffer_size)
522
 
            length = cfunc(key, buffer, buffer_size)
523
 
            if not length:
524
 
                code = ctypes.GetLastError()
525
 
                if code == 203: # ERROR_ENVVAR_NOT_FOUND
526
 
                    return default
527
 
                raise ctypes.WinError(code)
528
 
            if buffer_size > length:
529
 
                return buffer[:length]
530
 
            buffer_size = length
531
 
 
532
 
 
533
 
if has_win32api:
534
 
    def _pywin32_is_local_pid_dead(pid):
535
 
        """True if pid doesn't correspond to live process on this machine"""
536
 
        try:
537
 
            handle = win32api.OpenProcess(1, False, pid) # PROCESS_TERMINATE
538
 
        except pywintypes.error as e:
539
 
            if e[0] == 5: # ERROR_ACCESS_DENIED
540
 
                # Probably something alive we're not allowed to kill
541
 
                return False
542
 
            elif e[0] == 87: # ERROR_INVALID_PARAMETER
543
 
                return True
544
 
            raise
545
 
        handle.close()
546
 
        return False
547
 
    is_local_pid_dead = _pywin32_is_local_pid_dead
548
 
elif has_ctypes and sys.platform == 'win32':
549
 
    from ctypes.wintypes import BOOL, DWORD, HANDLE
550
 
    _kernel32 = ctypes.windll.kernel32
551
 
    _CloseHandle = ctypes.WINFUNCTYPE(BOOL, HANDLE)(
552
 
        ("CloseHandle", _kernel32))
553
 
    _OpenProcess = ctypes.WINFUNCTYPE(HANDLE, DWORD, BOOL, DWORD)(
554
 
        ("OpenProcess", _kernel32))
555
 
    def _ctypes_is_local_pid_dead(pid):
556
 
        """True if pid doesn't correspond to live process on this machine"""
557
 
        handle = _OpenProcess(1, False, pid) # PROCESS_TERMINATE
558
 
        if not handle:
559
 
            errorcode = ctypes.GetLastError()
560
 
            if errorcode == 5: # ERROR_ACCESS_DENIED
561
 
                # Probably something alive we're not allowed to kill
562
 
                return False
563
 
            elif errorcode == 87: # ERROR_INVALID_PARAMETER
564
 
                return True
565
 
            raise ctypes.WinError(errorcode)
566
 
        _CloseHandle(handle)
567
 
        return False
568
 
    is_local_pid_dead = _ctypes_is_local_pid_dead
569
 
 
570
 
 
571
 
def _is_pywintypes_error(evalue):
572
 
    """True if exception instance is an error from pywin32"""
573
 
    if has_pywintypes and isinstance(evalue, pywintypes.error):
574
 
        return True
575
 
    return False
 
660
else:
 
661
    get_unicode_argv = None