/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: Breezy landing bot
  • Author(s): Colin Watson
  • Date: 2020-11-16 21:47:08 UTC
  • mfrom: (7521.1.1 remove-lp-workaround)
  • Revision ID: breezy.the.bot@gmail.com-20201116214708-jos209mgxi41oy15
Remove breezy.git workaround for bazaar.launchpad.net.

Merged from https://code.launchpad.net/~cjwatson/brz/remove-lp-workaround/+merge/393710

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/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 bzrlib import (
 
27
from breezy import (
31
28
    cmdline,
32
 
    symbol_versioning,
33
29
    )
34
 
from bzrlib.i18n import gettext
35
 
 
36
 
# Windows version
37
 
if sys.platform == 'win32':
38
 
    _major,_minor,_build,_platform,_text = sys.getwindowsversion()
39
 
    # from MSDN:
40
 
    # dwPlatformId
41
 
    #   The operating system platform.
42
 
    #   This member can be one of the following values.
43
 
    #   ==========================  ======================================
44
 
    #   Value                       Meaning
45
 
    #   --------------------------  --------------------------------------
46
 
    #   VER_PLATFORM_WIN32_NT       The operating system is Windows Vista,
47
 
    #   2                           Windows Server "Longhorn",
48
 
    #                               Windows Server 2003, Windows XP,
49
 
    #                               Windows 2000, or Windows NT.
50
 
    #
51
 
    #   VER_PLATFORM_WIN32_WINDOWS  The operating system is Windows Me,
52
 
    #   1                           Windows 98, or Windows 95.
53
 
    #   ==========================  ======================================
54
 
    if _platform == 2:
55
 
        winver = 'Windows NT'
56
 
    else:
57
 
        # don't care about real Windows name, just to force safe operations
58
 
        winver = 'Windows 98'
59
 
else:
60
 
    winver = None
61
 
 
62
 
 
63
 
# We can cope without it; use a separate variable to help pyflakes
64
 
try:
65
 
    import ctypes
66
 
    has_ctypes = True
67
 
except ImportError:
68
 
    has_ctypes = False
69
 
else:
70
 
    if winver == 'Windows 98':
71
 
        create_buffer = ctypes.create_string_buffer
72
 
        def extract_buffer(buf):
73
 
            return buf.value.decode("mbcs")
74
 
        suffix = 'A'
75
 
    else:
76
 
        create_buffer = ctypes.create_unicode_buffer
77
 
        extract_buffer = operator.attrgetter("value")
78
 
        suffix = 'W'
79
 
try:
80
 
    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
95
 
 
96
 
# pulling in win32com.shell is a bit of overhead, and normally we don't need
97
 
# it as ctypes is preferred and common.  lazy_imports and "optional"
98
 
# modules don't work well, so we do our own lazy thing...
99
 
has_win32com_shell = None # Set to True or False once we know for sure...
 
30
from breezy.i18n import gettext
 
31
 
100
32
 
101
33
# Special Win32 API constants
102
34
# Handles of std streams
106
38
 
107
39
# CSIDL constants (from MSDN 2003)
108
40
CSIDL_APPDATA = 0x001A      # Application Data folder
109
 
CSIDL_LOCAL_APPDATA = 0x001c# <user name>\Local Settings\Application Data (non roaming)
 
41
# <user name>\Local Settings\Application Data (non roaming)
 
42
CSIDL_LOCAL_APPDATA = 0x001c
110
43
CSIDL_PERSONAL = 0x0005     # My Documents folder
111
44
 
112
45
# from winapi C headers
121
54
 
122
55
def debug_memory_win32api(message='', short=True):
123
56
    """Use trace.note() to dump the running memory info."""
124
 
    from bzrlib import trace
125
 
    if has_ctypes:
126
 
        class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
127
 
            """Used by GetProcessMemoryInfo"""
128
 
            _fields_ = [('cb', ctypes.c_ulong),
129
 
                        ('PageFaultCount', ctypes.c_ulong),
130
 
                        ('PeakWorkingSetSize', ctypes.c_size_t),
131
 
                        ('WorkingSetSize', ctypes.c_size_t),
132
 
                        ('QuotaPeakPagedPoolUsage', ctypes.c_size_t),
133
 
                        ('QuotaPagedPoolUsage', ctypes.c_size_t),
134
 
                        ('QuotaPeakNonPagedPoolUsage', ctypes.c_size_t),
135
 
                        ('QuotaNonPagedPoolUsage', ctypes.c_size_t),
136
 
                        ('PagefileUsage', ctypes.c_size_t),
137
 
                        ('PeakPagefileUsage', ctypes.c_size_t),
138
 
                        ('PrivateUsage', ctypes.c_size_t),
139
 
                       ]
140
 
        cur_process = ctypes.windll.kernel32.GetCurrentProcess()
141
 
        mem_struct = PROCESS_MEMORY_COUNTERS_EX()
142
 
        ret = ctypes.windll.psapi.GetProcessMemoryInfo(cur_process,
143
 
            ctypes.byref(mem_struct),
144
 
            ctypes.sizeof(mem_struct))
145
 
        if not ret:
146
 
            trace.note(gettext('Failed to GetProcessMemoryInfo()'))
147
 
            return
148
 
        info = {'PageFaultCount': mem_struct.PageFaultCount,
149
 
                'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
150
 
                'WorkingSetSize': mem_struct.WorkingSetSize,
151
 
                'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
152
 
                'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
153
 
                'QuotaPeakNonPagedPoolUsage':
154
 
                    mem_struct.QuotaPeakNonPagedPoolUsage,
155
 
                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
156
 
                'PagefileUsage': mem_struct.PagefileUsage,
157
 
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
158
 
                'PrivateUsage': mem_struct.PrivateUsage,
159
 
               }
160
 
    elif has_win32api:
161
 
        import win32process
162
 
        # win32process does not return PrivateUsage, because it doesn't use
163
 
        # PROCESS_MEMORY_COUNTERS_EX (it uses the one without _EX).
164
 
        proc = win32process.GetCurrentProcess()
165
 
        info = win32process.GetProcessMemoryInfo(proc)
166
 
    else:
167
 
        trace.note(gettext('Cannot debug memory on win32 without ctypes'
168
 
                   ' or win32process'))
 
57
    import ctypes
 
58
    from breezy import trace
 
59
    class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
 
60
        """Used by GetProcessMemoryInfo"""
 
61
        _fields_ = [('cb', ctypes.c_ulong),
 
62
                    ('PageFaultCount', ctypes.c_ulong),
 
63
                    ('PeakWorkingSetSize', ctypes.c_size_t),
 
64
                    ('WorkingSetSize', ctypes.c_size_t),
 
65
                    ('QuotaPeakPagedPoolUsage', ctypes.c_size_t),
 
66
                    ('QuotaPagedPoolUsage', ctypes.c_size_t),
 
67
                    ('QuotaPeakNonPagedPoolUsage', ctypes.c_size_t),
 
68
                    ('QuotaNonPagedPoolUsage', ctypes.c_size_t),
 
69
                    ('PagefileUsage', ctypes.c_size_t),
 
70
                    ('PeakPagefileUsage', ctypes.c_size_t),
 
71
                    ('PrivateUsage', ctypes.c_size_t),
 
72
                    ]
 
73
    cur_process = ctypes.windll.kernel32.GetCurrentProcess()
 
74
    mem_struct = PROCESS_MEMORY_COUNTERS_EX()
 
75
    ret = ctypes.windll.psapi.GetProcessMemoryInfo(
 
76
        cur_process, ctypes.byref(mem_struct), ctypes.sizeof(mem_struct))
 
77
    if not ret:
 
78
        trace.note(gettext('Failed to GetProcessMemoryInfo()'))
169
79
        return
 
80
    info = {'PageFaultCount': mem_struct.PageFaultCount,
 
81
            'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
 
82
            'WorkingSetSize': mem_struct.WorkingSetSize,
 
83
            'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
 
84
            'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
 
85
            'QuotaPeakNonPagedPoolUsage':
 
86
                mem_struct.QuotaPeakNonPagedPoolUsage,
 
87
            'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
 
88
            'PagefileUsage': mem_struct.PagefileUsage,
 
89
            'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
 
90
            'PrivateUsage': mem_struct.PrivateUsage,
 
91
            }
170
92
    if short:
171
93
        # using base-2 units (see HACKING.txt).
172
94
        trace.note(gettext('WorkingSize {0:>7}KiB'
173
 
                   '\tPeakWorking {1:>7}KiB\t{2}').format(
 
95
                           '\tPeakWorking {1:>7}KiB\t{2}').format(
174
96
                   info['WorkingSetSize'] / 1024,
175
97
                   info['PeakWorkingSetSize'] / 1024,
176
98
                   message))
177
99
        return
178
100
    if message:
179
101
        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)
 
102
    trace.note(gettext('WorkingSize       %8d KiB'),
 
103
               info['WorkingSetSize'] / 1024)
 
104
    trace.note(gettext('PeakWorking       %8d KiB'),
 
105
               info['PeakWorkingSetSize'] / 1024)
 
106
    trace.note(gettext('PagefileUsage     %8d KiB'),
 
107
               info.get('PagefileUsage', 0) / 1024)
183
108
    trace.note(gettext('PeakPagefileUsage %8d KiB'),
184
109
               info.get('PeakPagefileUsage', 0) / 1024)
185
 
    trace.note(gettext('PrivateUsage      %8d KiB'), info.get('PrivateUsage', 0) / 1024)
 
110
    trace.note(gettext('PrivateUsage      %8d KiB'),
 
111
               info.get('PrivateUsage', 0) / 1024)
186
112
    trace.note(gettext('PageFaultCount    %8d'), info.get('PageFaultCount', 0))
187
113
 
188
114
 
193
119
    console window and return tuple (sizex, sizey) if success,
194
120
    or default size (defaultx, defaulty) otherwise.
195
121
    """
196
 
    if not has_ctypes:
197
 
        # no ctypes is found
198
 
        return (defaultx, defaulty)
199
 
 
 
122
    import ctypes
200
123
    # To avoid problem with redirecting output via pipe
201
124
    # we need to use stderr instead of stdout
202
125
    h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
205
128
 
206
129
    if res:
207
130
        (bufx, bufy, curx, cury, wattr,
208
 
        left, top, right, bottom, maxx, maxy) = struct.unpack(
 
131
         left, top, right, bottom, maxx, maxy) = struct.unpack(
209
132
            "hhhhHhhhhhh", csbi.raw)
210
133
        sizex = right - left + 1
211
134
        sizey = bottom - top + 1
219
142
 
220
143
    Result is always unicode (or None).
221
144
    """
222
 
    if has_ctypes:
223
 
        try:
224
 
            SHGetSpecialFolderPath = \
225
 
                ctypes.windll.shell32.SHGetSpecialFolderPathW
226
 
        except AttributeError:
227
 
            pass
228
 
        else:
229
 
            buf = ctypes.create_unicode_buffer(MAX_PATH)
230
 
            if SHGetSpecialFolderPath(None,buf,csidl,0):
231
 
                return buf.value
232
 
 
233
 
    global has_win32com_shell
234
 
    if has_win32com_shell is None:
235
 
        try:
236
 
            from win32com.shell import shell
237
 
            has_win32com_shell = True
238
 
        except ImportError:
239
 
            has_win32com_shell = False
240
 
    if has_win32com_shell:
241
 
        # still need to bind the name locally, but this is fast.
242
 
        from win32com.shell import shell
243
 
        try:
244
 
            return shell.SHGetSpecialFolderPath(0, csidl, 0)
245
 
        except shell.error:
246
 
            # possibly E_NOTIMPL meaning we can't load the function pointer,
247
 
            # or E_FAIL meaning the function failed - regardless, just ignore it
248
 
            pass
249
 
    return None
 
145
    import ctypes
 
146
    try:
 
147
        SHGetSpecialFolderPath = \
 
148
            ctypes.windll.shell32.SHGetSpecialFolderPathW
 
149
    except AttributeError:
 
150
        pass
 
151
    else:
 
152
        buf = ctypes.create_unicode_buffer(MAX_PATH)
 
153
        if SHGetSpecialFolderPath(None, buf, csidl, 0):
 
154
            return buf.value
250
155
 
251
156
 
252
157
def get_appdata_location():
262
167
    if appdata:
263
168
        return appdata
264
169
    # Use APPDATA if defined, will return None if not
265
 
    return get_environ_unicode('APPDATA')
 
170
    return os.environ.get('APPDATA')
266
171
 
267
172
 
268
173
def get_local_appdata_location():
279
184
    if local:
280
185
        return local
281
186
    # Vista supplies LOCALAPPDATA, but XP and earlier do not.
282
 
    local = get_environ_unicode('LOCALAPPDATA')
 
187
    local = os.environ.get('LOCALAPPDATA')
283
188
    if local:
284
189
        return local
285
190
    return get_appdata_location()
294
199
    home = _get_sh_special_folder_path(CSIDL_PERSONAL)
295
200
    if home:
296
201
        return home
297
 
    home = get_environ_unicode('HOME')
 
202
    home = os.environ.get('HOME')
298
203
    if home is not None:
299
204
        return home
300
 
    homepath = get_environ_unicode('HOMEPATH')
 
205
    homepath = os.environ.get('HOMEPATH')
301
206
    if homepath is not None:
302
 
        return os.path.join(get_environ_unicode('HOMEDIR', ''), home)
 
207
        return os.path.join(os.environ.get('HOMEDIR', ''), home)
303
208
    # at least return windows root directory
304
 
    windir = get_environ_unicode('WINDIR')
 
209
    windir = os.environ.get('WINDIR')
305
210
    if windir:
306
211
        return os.path.splitdrive(windir)[0] + '/'
307
212
    # otherwise C:\ is good enough for 98% users
308
 
    return unicode('C:/')
 
213
    return u'C:/'
309
214
 
310
215
 
311
216
def get_user_name():
312
217
    """Return user name as login name.
313
218
    If name cannot be obtained return None.
314
219
    """
315
 
    if has_ctypes:
316
 
        try:
317
 
            advapi32 = ctypes.windll.advapi32
318
 
            GetUserName = getattr(advapi32, 'GetUserName'+suffix)
319
 
        except AttributeError:
320
 
            pass
321
 
        else:
322
 
            buf = create_buffer(UNLEN+1)
323
 
            n = ctypes.c_int(UNLEN+1)
324
 
            if GetUserName(buf, ctypes.byref(n)):
325
 
                return extract_buffer(buf)
 
220
    try:
 
221
        advapi32 = ctypes.windll.advapi32
 
222
        GetUserName = getattr(advapi32, 'GetUserNameW')
 
223
    except AttributeError:
 
224
        pass
 
225
    else:
 
226
        buf = ctypes.create_unicode_buffer(UNLEN + 1)
 
227
        n = ctypes.c_int(UNLEN + 1)
 
228
        if GetUserName(buf, ctypes.byref(n)):
 
229
            return buf.value
326
230
    # otherwise try env variables
327
 
    return get_environ_unicode('USERNAME')
 
231
    return os.environ.get('USERNAME')
328
232
 
329
233
 
330
234
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
331
235
# computer or the cluster associated with the local computer."
332
236
_WIN32_ComputerNameDnsHostname = 1
333
237
 
 
238
 
334
239
def get_host_name():
335
240
    """Return host machine name.
336
241
    If name cannot be obtained return None.
337
242
 
338
243
    :return: A unicode string representing the host name.
339
244
    """
340
 
    if has_win32api:
341
 
        try:
342
 
            return win32api.GetComputerNameEx(_WIN32_ComputerNameDnsHostname)
343
 
        except (NotImplementedError, win32api.error):
344
 
            # NotImplemented will happen on win9x...
345
 
            pass
346
 
    if has_ctypes:
347
 
        try:
348
 
            kernel32 = ctypes.windll.kernel32
349
 
        except AttributeError:
350
 
            pass # Missing the module we need
351
 
        else:
352
 
            buf = create_buffer(MAX_COMPUTERNAME_LENGTH+1)
353
 
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
354
 
 
355
 
            # Try GetComputerNameEx which gives a proper Unicode hostname
356
 
            GetComputerNameEx = getattr(kernel32, 'GetComputerNameEx'+suffix,
357
 
                                        None)
358
 
            if (GetComputerNameEx is not None
359
 
                and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
360
 
                                      buf, ctypes.byref(n))):
361
 
                return extract_buffer(buf)
362
 
 
363
 
            # Try GetComputerName in case GetComputerNameEx wasn't found
364
 
            # It returns the NETBIOS name, which isn't as good, but still ok.
365
 
            # The first GetComputerNameEx might have changed 'n', so reset it
366
 
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
367
 
            GetComputerName = getattr(kernel32, 'GetComputerName'+suffix,
368
 
                                      None)
369
 
            if (GetComputerName is not None
370
 
                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)))
377
 
def _ensure_unicode(s):
378
 
    if s and type(s) != unicode:
379
 
        from bzrlib import osutils
380
 
        s = s.decode(osutils.get_user_encoding())
381
 
    return s
382
 
 
383
 
 
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)
 
245
    import ctypes
 
246
    buf = ctypes.create_unicode_buffer(MAX_COMPUTERNAME_LENGTH + 1)
 
247
    n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH + 1)
 
248
 
 
249
    # Try GetComputerNameEx which gives a proper Unicode hostname
 
250
    GetComputerNameEx = getattr(
 
251
        ctypes.windll.kernel32, 'GetComputerNameExW', None)
 
252
    if (GetComputerNameEx is not None
 
253
        and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
 
254
                              buf, ctypes.byref(n))):
 
255
        return buf.value
 
256
    return os.environ.get('COMPUTERNAME')
395
257
 
396
258
 
397
259
def _ensure_with_dir(path):
398
260
    if (not os.path.split(path)[0] or path.startswith(u'*')
399
 
        or path.startswith(u'?')):
 
261
            or path.startswith(u'?')):
400
262
        return u'./' + path, True
401
263
    else:
402
264
        return path, False
403
265
 
 
266
 
404
267
def _undo_ensure_with_dir(path, corrected):
405
268
    if corrected:
406
269
        return path[2:]
437
300
    :param file_list: A list of filenames which may include shell globs.
438
301
    :return: An expanded list of filenames.
439
302
 
440
 
    Introduced in bzrlib 0.18.
 
303
    Introduced in breezy 0.18.
441
304
    """
442
305
    if not file_list:
443
306
        return []
465
328
 
466
329
    try:
467
330
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
468
 
            'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
469
 
            basename)
 
331
                               'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
 
332
                               basename)
470
333
    except EnvironmentError:
471
334
        return appname
472
335
 
480
343
 
481
344
    if type_id == REG_SZ:
482
345
        return path
483
 
    if type_id == REG_EXPAND_SZ and has_win32api:
484
 
        fullpath = win32api.ExpandEnvironmentStrings(path)
485
 
        if len(fullpath) > 1 and fullpath[0] == '"' and fullpath[-1] == '"':
486
 
            fullpath = fullpath[1:-1]   # remove quotes around value
487
 
        return fullpath
488
346
    return appname
489
347
 
490
348
 
491
349
def set_file_attr_hidden(path):
492
350
    """Set file attributes to hidden if possible"""
493
 
    if has_win32file:
494
 
        if winver != 'Windows 98':
495
 
            SetFileAttributes = win32file.SetFileAttributesW
496
 
        else:
497
 
            SetFileAttributes = win32file.SetFileAttributes
498
 
        try:
499
 
            SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
500
 
        except pywintypes.error, e:
501
 
            from bzrlib import trace
502
 
            trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
 
351
    from ctypes.wintypes import BOOL, DWORD, LPWSTR
 
352
    import ctypes
 
353
    # <https://docs.microsoft.com/windows/desktop/api/fileapi/nf-fileapi-setfileattributesw>
 
354
    SetFileAttributes = ctypes.windll.kernel32.SetFileAttributesW
 
355
    SetFileAttributes.argtypes = LPWSTR, DWORD
 
356
    SetFileAttributes.restype = BOOL
 
357
    FILE_ATTRIBUTE_HIDDEN = 2
 
358
    if not SetFileAttributes(path, FILE_ATTRIBUTE_HIDDEN):
 
359
        e = ctypes.WinError()
 
360
        from . import trace
 
361
        trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
503
362
 
504
363
 
505
364
def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
516
375
    :return: A list of unicode strings.
517
376
    """
518
377
    # 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 
 
378
    s = cmdline.Splitter(
 
379
        command_line, single_quotes_allowed=single_quotes_allowed)
 
380
 
 
381
    # Bug #587868 Now make sure that the length of s agrees with sys.argv
 
382
    # we do this by simply counting the number of arguments in each. The counts should
 
383
    # agree no matter what encoding sys.argv is in (AFAIK)
 
384
    # len(arguments) < len(sys.argv) should be an impossibility since python gets
525
385
    # args from the very same PEB as does GetCommandLineW
526
386
    arguments = list(s)
527
 
    
 
387
 
528
388
    # Now shorten the command line we get from GetCommandLineW to match sys.argv
529
389
    if len(arguments) < len(argv):
530
390
        raise AssertionError("Split command line can't be shorter than argv")
531
391
    arguments = arguments[len(arguments) - len(argv):]
532
 
    
 
392
 
533
393
    # Carry on to process globs (metachars) in the command line
534
394
    # expand globs if necessary
535
395
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
543
403
    return args
544
404
 
545
405
 
546
 
if has_ctypes and winver == 'Windows NT':
547
 
    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()
554
 
        # Skip the first argument, since we only care about parameters
555
 
        argv = _command_line_to_argv(command_line, sys.argv)[1:]
556
 
        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
 
else:
591
 
    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
 
406
def _ctypes_is_local_pid_dead(pid):
 
407
    import ctypes
 
408
    kernel32 = ctypes.wintypes.windll.kernel32
 
409
    """True if pid doesn't correspond to live process on this machine"""
 
410
    handle = kernel32.OpenProcess(1, False, pid)
 
411
    if not handle:
 
412
        errorcode = ctypes.GetLastError()
 
413
        if errorcode == 5:  # ERROR_ACCESS_DENIED
 
414
            # Probably something alive we're not allowed to kill
 
415
            return False
 
416
        elif errorcode == 87:  # ERROR_INVALID_PARAMETER
 
417
            return True
 
418
        raise ctypes.WinError(errorcode)
 
419
    Kernel32.CloseHandle(handle)
646
420
    return False
 
421
 
 
422
is_local_pid_dead = _ctypes_is_local_pid_dead