/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: Canonical.com Patch Queue Manager
  • Date: 2010-02-11 04:02:41 UTC
  • mfrom: (5017.2.2 tariff)
  • Revision ID: pqm@pqm.ubuntu.com-20100211040241-w6n021dz0uus341n
(mbp) add import-tariff tests

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
23
import os
 
24
import re
26
25
import struct
27
26
import sys
28
27
 
29
 
from breezy import (
30
 
    cmdline,
31
 
    )
32
 
from breezy.i18n import gettext
33
28
 
34
 
has_ctypes_win32 = False
 
29
# Windows version
35
30
if sys.platform == 'win32':
36
 
    try:
37
 
        import ctypes
38
 
    except ImportError:
39
 
        has_ctypes_win32 = False
40
 
 
 
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...
41
85
 
42
86
# Special Win32 API constants
43
87
# Handles of std streams
47
91
 
48
92
# CSIDL constants (from MSDN 2003)
49
93
CSIDL_APPDATA = 0x001A      # Application Data folder
50
 
# <user name>\Local Settings\Application Data (non roaming)
51
 
CSIDL_LOCAL_APPDATA = 0x001c
 
94
CSIDL_LOCAL_APPDATA = 0x001c# <user name>\Local Settings\Application Data (non roaming)
52
95
CSIDL_PERSONAL = 0x0005     # My Documents folder
53
96
 
54
97
# from winapi C headers
63
106
 
64
107
def debug_memory_win32api(message='', short=True):
65
108
    """Use trace.note() to dump the running memory info."""
66
 
    from breezy import trace
67
 
    if has_ctypes_win32:
 
109
    from bzrlib import trace
 
110
    if has_ctypes:
68
111
        class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
69
112
            """Used by GetProcessMemoryInfo"""
70
113
            _fields_ = [('cb', ctypes.c_ulong),
78
121
                        ('PagefileUsage', ctypes.c_size_t),
79
122
                        ('PeakPagefileUsage', ctypes.c_size_t),
80
123
                        ('PrivateUsage', ctypes.c_size_t),
81
 
                        ]
 
124
                       ]
82
125
        cur_process = ctypes.windll.kernel32.GetCurrentProcess()
83
126
        mem_struct = PROCESS_MEMORY_COUNTERS_EX()
84
 
        ret = ctypes.windll.psapi.GetProcessMemoryInfo(
85
 
            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))
86
130
        if not ret:
87
 
            trace.note(gettext('Failed to GetProcessMemoryInfo()'))
 
131
            trace.note('Failed to GetProcessMemoryInfo()')
88
132
            return
89
133
        info = {'PageFaultCount': mem_struct.PageFaultCount,
90
134
                'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
97
141
                'PagefileUsage': mem_struct.PagefileUsage,
98
142
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
99
143
                'PrivateUsage': mem_struct.PrivateUsage,
100
 
                }
 
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)
101
151
    else:
102
 
        trace.note(gettext('Cannot debug memory on win32 without ctypes'
103
 
                           ' or win32process'))
 
152
        trace.note('Cannot debug memory on win32 without ctypes'
 
153
                   ' or win32process')
104
154
        return
105
155
    if short:
106
156
        # using base-2 units (see HACKING.txt).
107
 
        trace.note(gettext('WorkingSize {0:>7}KiB'
108
 
                           '\tPeakWorking {1:>7}KiB\t{2}').format(
 
157
        trace.note('WorkingSize %7dKiB'
 
158
                   '\tPeakWorking %7dKiB\t%s',
109
159
                   info['WorkingSetSize'] / 1024,
110
160
                   info['PeakWorkingSetSize'] / 1024,
111
 
                   message))
 
161
                   message)
112
162
        return
113
163
    if message:
114
164
        trace.note('%s', message)
115
 
    trace.note(gettext('WorkingSize       %8d KiB'),
116
 
               info['WorkingSetSize'] / 1024)
117
 
    trace.note(gettext('PeakWorking       %8d KiB'),
118
 
               info['PeakWorkingSetSize'] / 1024)
119
 
    trace.note(gettext('PagefileUsage     %8d KiB'),
120
 
               info.get('PagefileUsage', 0) / 1024)
121
 
    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',
122
169
               info.get('PeakPagefileUsage', 0) / 1024)
123
 
    trace.note(gettext('PrivateUsage      %8d KiB'),
124
 
               info.get('PrivateUsage', 0) / 1024)
125
 
    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))
126
172
 
127
173
 
128
174
def get_console_size(defaultx=80, defaulty=25):
132
178
    console window and return tuple (sizex, sizey) if success,
133
179
    or default size (defaultx, defaulty) otherwise.
134
180
    """
135
 
    if not has_ctypes_win32:
 
181
    if not has_ctypes:
136
182
        # no ctypes is found
137
183
        return (defaultx, defaulty)
138
184
 
144
190
 
145
191
    if res:
146
192
        (bufx, bufy, curx, cury, wattr,
147
 
         left, top, right, bottom, maxx, maxy) = struct.unpack(
 
193
        left, top, right, bottom, maxx, maxy) = struct.unpack(
148
194
            "hhhhHhhhhhh", csbi.raw)
149
195
        sizex = right - left + 1
150
196
        sizey = bottom - top + 1
158
204
 
159
205
    Result is always unicode (or None).
160
206
    """
161
 
    if has_ctypes_win32:
 
207
    if has_ctypes:
162
208
        try:
163
209
            SHGetSpecialFolderPath = \
164
210
                ctypes.windll.shell32.SHGetSpecialFolderPathW
166
212
            pass
167
213
        else:
168
214
            buf = ctypes.create_unicode_buffer(MAX_PATH)
169
 
            if SHGetSpecialFolderPath(None, buf, csidl, 0):
 
215
            if SHGetSpecialFolderPath(None,buf,csidl,0):
170
216
                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
171
234
    return None
172
235
 
173
236
 
179
242
    one that moves with the user as they logon to different machines, and
180
243
    a 'local' one that stays local to the machine.  This returns the 'roaming'
181
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')
182
250
    """
183
251
    appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
184
252
    if appdata:
185
253
        return appdata
186
 
    # Use APPDATA if defined, will return None if not
187
 
    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
188
267
 
189
268
 
190
269
def get_local_appdata_location():
196
275
    a 'local' one that stays local to the machine.  This returns the 'local'
197
276
    directory, and thus is suitable for caches, temp files and other things
198
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')
199
283
    """
200
284
    local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
201
285
    if local:
202
286
        return local
203
287
    # Vista supplies LOCALAPPDATA, but XP and earlier do not.
204
 
    local = get_environ_unicode('LOCALAPPDATA')
 
288
    local = os.environ.get('LOCALAPPDATA')
205
289
    if local:
206
290
        return local
207
291
    return get_appdata_location()
212
296
    Assume on win32 it's the <My Documents> folder.
213
297
    If location cannot be obtained return system drive root,
214
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())
215
303
    """
216
304
    home = _get_sh_special_folder_path(CSIDL_PERSONAL)
217
305
    if home:
218
306
        return home
219
 
    home = get_environ_unicode('HOME')
220
 
    if home is not None:
 
307
    # try for HOME env variable
 
308
    home = os.path.expanduser('~')
 
309
    if home != '~':
221
310
        return home
222
 
    homepath = get_environ_unicode('HOMEPATH')
223
 
    if homepath is not None:
224
 
        return os.path.join(get_environ_unicode('HOMEDIR', ''), home)
225
311
    # at least return windows root directory
226
 
    windir = get_environ_unicode('WINDIR')
 
312
    windir = os.environ.get('windir')
227
313
    if windir:
228
314
        return os.path.splitdrive(windir)[0] + '/'
229
315
    # otherwise C:\ is good enough for 98% users
230
 
    return u'C:/'
 
316
    return 'C:/'
231
317
 
232
318
 
233
319
def get_user_name():
234
320
    """Return user name as login name.
235
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())
236
326
    """
237
 
    if has_ctypes_win32:
 
327
    if has_ctypes:
238
328
        try:
239
329
            advapi32 = ctypes.windll.advapi32
240
 
            GetUserName = getattr(advapi32, 'GetUserNameW')
 
330
            GetUserName = getattr(advapi32, 'GetUserName'+suffix)
241
331
        except AttributeError:
242
332
            pass
243
333
        else:
244
 
            buf = ctypes.create_unicode_buffer(UNLEN + 1)
245
 
            n = ctypes.c_int(UNLEN + 1)
 
334
            buf = create_buffer(UNLEN+1)
 
335
            n = ctypes.c_int(UNLEN+1)
246
336
            if GetUserName(buf, ctypes.byref(n)):
247
337
                return buf.value
248
338
    # otherwise try env variables
249
 
    return get_environ_unicode('USERNAME')
 
339
    return os.environ.get('USERNAME', None)
250
340
 
251
341
 
252
342
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
253
343
# computer or the cluster associated with the local computer."
254
344
_WIN32_ComputerNameDnsHostname = 1
255
345
 
256
 
 
257
346
def get_host_name():
258
347
    """Return host machine name.
259
348
    If name cannot be obtained return None.
260
349
 
261
 
    :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.
262
352
    """
263
 
    if has_ctypes_win32:
 
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:
264
360
        try:
265
361
            kernel32 = ctypes.windll.kernel32
266
362
        except AttributeError:
267
 
            pass  # Missing the module we need
 
363
            pass # Missing the module we need
268
364
        else:
269
 
            buf = ctypes.create_unicode_buffer(MAX_COMPUTERNAME_LENGTH + 1)
270
 
            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)
271
367
 
272
368
            # Try GetComputerNameEx which gives a proper Unicode hostname
273
 
            GetComputerNameEx = getattr(kernel32, 'GetComputerNameExW', None)
 
369
            GetComputerNameEx = getattr(kernel32, 'GetComputerNameEx'+suffix,
 
370
                                        None)
274
371
            if (GetComputerNameEx is not None
275
372
                and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
276
373
                                      buf, ctypes.byref(n))):
277
374
                return buf.value
278
 
    return get_environ_unicode('COMPUTERNAME')
 
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())
279
414
 
280
415
 
281
416
def _ensure_with_dir(path):
282
417
    if (not os.path.split(path)[0] or path.startswith(u'*')
283
 
            or path.startswith(u'?')):
 
418
        or path.startswith(u'?')):
284
419
        return u'./' + path, True
285
420
    else:
286
421
        return path, False
287
422
 
288
 
 
289
423
def _undo_ensure_with_dir(path, corrected):
290
424
    if corrected:
291
425
        return path[2:]
293
427
        return path
294
428
 
295
429
 
 
430
 
296
431
def glob_one(possible_glob):
297
432
    """Same as glob.glob().
298
433
 
322
457
    :param file_list: A list of filenames which may include shell globs.
323
458
    :return: An expanded list of filenames.
324
459
 
325
 
    Introduced in breezy 0.18.
 
460
    Introduced in bzrlib 0.18.
326
461
    """
327
462
    if not file_list:
328
463
        return []
333
468
 
334
469
 
335
470
def get_app_path(appname):
336
 
    r"""Look up in Windows registry for full path to application executable.
 
471
    """Look up in Windows registry for full path to application executable.
337
472
    Typically, applications create subkey with their basename
338
473
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
339
474
 
350
485
 
351
486
    try:
352
487
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
353
 
                               'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
354
 
                               basename)
 
488
            'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
 
489
            basename)
355
490
    except EnvironmentError:
356
491
        return appname
357
492
 
375
510
 
376
511
def set_file_attr_hidden(path):
377
512
    """Set file attributes to hidden if possible"""
378
 
    if not has_ctypes_win32:
379
 
        return
380
 
    from ctypes.wintypes import BOOL, DWORD, LPCWSTR
381
 
    _kernel32 = ctypes.windll.kernel32
382
 
    # <https://docs.microsoft.com/windows/desktop/api/fileapi/nf-fileapi-setfileattributesw>
383
 
    _SetFileAttributesW = ctypes.WINFUNCTYPE(BOOL, LPCWSTR, DWORD)(
384
 
        ("SetFileAttributesW", _kernel32))
385
 
    FILE_ATTRIBUTE_HIDDEN = 2
386
 
    if not SetFileAttributes(path, FILE_ATTRIBUTE_HIDDEN):
387
 
        e = ctypes.WinError()
388
 
        from . import trace
389
 
        trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
390
 
 
391
 
 
392
 
def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
393
 
    """Convert a Unicode command line into a list of argv arguments.
394
 
 
395
 
    It performs wildcard expansion to make wildcards act closer to how they
396
 
    work in posix shells, versus how they work by default on Windows. Quoted
397
 
    arguments are left untouched.
398
 
 
399
 
    :param command_line: The unicode string to split into an arg list.
400
 
    :param single_quotes_allowed: Whether single quotes are accepted as quoting
401
 
                                  characters like double quotes. False by
402
 
                                  default.
403
 
    :return: A list of unicode strings.
404
 
    """
405
 
    # First, split the command line
406
 
    s = cmdline.Splitter(
407
 
        command_line, single_quotes_allowed=single_quotes_allowed)
408
 
 
409
 
    # Bug #587868 Now make sure that the length of s agrees with sys.argv
410
 
    # we do this by simply counting the number of arguments in each. The counts should
411
 
    # agree no matter what encoding sys.argv is in (AFAIK)
412
 
    # len(arguments) < len(sys.argv) should be an impossibility since python gets
413
 
    # args from the very same PEB as does GetCommandLineW
414
 
    arguments = list(s)
415
 
 
416
 
    # Now shorten the command line we get from GetCommandLineW to match sys.argv
417
 
    if len(arguments) < len(argv):
418
 
        raise AssertionError("Split command line can't be shorter than argv")
419
 
    arguments = arguments[len(arguments) - len(argv):]
420
 
 
421
 
    # Carry on to process globs (metachars) in the command line
422
 
    # expand globs if necessary
 
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
 
 
526
class UnicodeShlex(object):
 
527
    """This is a very simplified version of shlex.shlex.
 
528
 
 
529
    The main change is that it supports non-ascii input streams. The internal
 
530
    structure is quite simplified relative to shlex.shlex, since we aren't
 
531
    trying to handle multiple input streams, etc. In fact, we don't use a
 
532
    file-like api either.
 
533
    """
 
534
 
 
535
    def __init__(self, uni_string):
 
536
        self._input = uni_string
 
537
        self._input_iter = iter(self._input)
 
538
        self._whitespace_match = re.compile(u'\s').match
 
539
        self._word_match = re.compile(u'\S').match
 
540
        self._quote_chars = u'"'
 
541
        # self._quote_match = re.compile(u'[\'"]').match
 
542
        self._escape_match = lambda x: None # Never matches
 
543
        self._escape = '\\'
 
544
        # State can be
 
545
        #   ' ' - after whitespace, starting a new token
 
546
        #   'a' - after text, currently working on a token
 
547
        #   '"' - after ", currently in a "-delimited quoted section
 
548
        #   "\" - after '\', checking the next char
 
549
        self._state = ' '
 
550
        self._token = [] # Current token being parsed
 
551
 
 
552
    def _get_token(self):
 
553
        # Were there quote chars as part of this token?
 
554
        quoted = False
 
555
        quoted_state = None
 
556
        for nextchar in self._input_iter:
 
557
            if self._state == ' ':
 
558
                if self._whitespace_match(nextchar):
 
559
                    # if self._token: return token
 
560
                    continue
 
561
                elif nextchar in self._quote_chars:
 
562
                    self._state = nextchar # quoted state
 
563
                elif self._word_match(nextchar):
 
564
                    self._token.append(nextchar)
 
565
                    self._state = 'a'
 
566
                else:
 
567
                    raise AssertionError('wtttf?')
 
568
            elif self._state in self._quote_chars:
 
569
                quoted = True
 
570
                if nextchar == self._state: # End of quote
 
571
                    self._state = 'a' # posix allows 'foo'bar to translate to
 
572
                                      # foobar
 
573
                elif self._state == '"' and nextchar == self._escape:
 
574
                    quoted_state = self._state
 
575
                    self._state = nextchar
 
576
                else:
 
577
                    self._token.append(nextchar)
 
578
            elif self._state == self._escape:
 
579
                if nextchar == '\\':
 
580
                    self._token.append('\\')
 
581
                elif nextchar == '"':
 
582
                    self._token.append(nextchar)
 
583
                else:
 
584
                    self._token.append('\\' + nextchar)
 
585
                self._state = quoted_state
 
586
            elif self._state == 'a':
 
587
                if self._whitespace_match(nextchar):
 
588
                    if self._token:
 
589
                        break # emit this token
 
590
                    else:
 
591
                        continue # no token to emit
 
592
                elif nextchar in self._quote_chars:
 
593
                    # Start a new quoted section
 
594
                    self._state = nextchar
 
595
                # escape?
 
596
                elif (self._word_match(nextchar)
 
597
                      or nextchar in self._quote_chars
 
598
                      # or whitespace_split?
 
599
                      ):
 
600
                    self._token.append(nextchar)
 
601
                else:
 
602
                    raise AssertionError('state == "a", char: %r'
 
603
                                         % (nextchar,))
 
604
            else:
 
605
                raise AssertionError('unknown state: %r' % (self._state,))
 
606
        result = ''.join(self._token)
 
607
        self._token = []
 
608
        if not quoted and result == '':
 
609
            result = None
 
610
        return quoted, result
 
611
 
 
612
    def __iter__(self):
 
613
        return self
 
614
 
 
615
    def next(self):
 
616
        quoted, token = self._get_token()
 
617
        if token is None:
 
618
            raise StopIteration
 
619
        return quoted, token
 
620
 
 
621
 
 
622
def _command_line_to_argv(command_line):
 
623
    """Convert a Unicode command line into a set of argv arguments.
 
624
 
 
625
    This does wildcard expansion, etc. It is intended to make wildcards act
 
626
    closer to how they work in posix shells, versus how they work by default on
 
627
    Windows.
 
628
    """
 
629
    s = UnicodeShlex(command_line)
 
630
    # Now that we've split the content, expand globs
423
631
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
424
632
    #       '**/' style globs
425
633
    args = []
426
 
    for is_quoted, arg in arguments:
 
634
    for is_quoted, arg in s:
427
635
        if is_quoted or not glob.has_magic(arg):
428
636
            args.append(arg)
429
637
        else:
431
639
    return args
432
640
 
433
641
 
434
 
if has_ctypes_win32:
 
642
if has_ctypes and winver != 'Windows 98':
435
643
    def get_unicode_argv():
436
 
        prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
437
 
        GetCommandLineW = prototype(("GetCommandLineW",
438
 
                                     ctypes.windll.kernel32))
439
 
        command_line = GetCommandLineW()
440
 
        if command_line is None:
441
 
            raise ctypes.WinError()
 
644
        LPCWSTR = ctypes.c_wchar_p
 
645
        INT = ctypes.c_int
 
646
        POINTER = ctypes.POINTER
 
647
        prototype = ctypes.WINFUNCTYPE(LPCWSTR)
 
648
        GetCommandLine = prototype(("GetCommandLineW",
 
649
                                    ctypes.windll.kernel32))
 
650
        prototype = ctypes.WINFUNCTYPE(POINTER(LPCWSTR), LPCWSTR, POINTER(INT))
 
651
        command_line = GetCommandLine()
442
652
        # Skip the first argument, since we only care about parameters
443
 
        argv = _command_line_to_argv(command_line, sys.argv)[1:]
 
653
        argv = _command_line_to_argv(command_line)[1:]
 
654
        if getattr(sys, 'frozen', None) is None:
 
655
            # Invoked via 'python.exe' which takes the form:
 
656
            #   python.exe [PYTHON_OPTIONS] C:\Path\bzr [BZR_OPTIONS]
 
657
            # we need to get only BZR_OPTIONS part,
 
658
            # We already removed 'python.exe' so we remove everything up to and
 
659
            # including the first non-option ('-') argument.
 
660
            for idx in xrange(len(argv)):
 
661
                if argv[idx][:1] != '-':
 
662
                    break
 
663
            argv = argv[idx+1:]
444
664
        return argv
445
 
 
446
 
    def get_environ_unicode(key, default=None):
447
 
        """Get `key` from environment as unicode or `default` if unset
448
 
 
449
 
        The environment is natively unicode on modern windows versions but
450
 
        Python 2 only accesses it through the legacy bytestring api.
451
 
 
452
 
        Environmental variable names are case insenstive on Windows.
453
 
 
454
 
        A large enough buffer will be allocated to retrieve the value, though
455
 
        it may take two calls to the underlying library function.
456
 
        """
457
 
        cfunc = getattr(get_environ_unicode, "_c_function", None)
458
 
        if cfunc is None:
459
 
            from ctypes.wintypes import DWORD, LPCWSTR, LPWSTR
460
 
            cfunc = ctypes.WINFUNCTYPE(DWORD, LPCWSTR, LPWSTR, DWORD)(
461
 
                ("GetEnvironmentVariableW", ctypes.windll.kernel32))
462
 
            get_environ_unicode._c_function = cfunc
463
 
        buffer_size = 256  # heuristic, 256 characters often enough
464
 
        while True:
465
 
            buf = ctypes.create_unicode_buffer(buffer_size)
466
 
            length = cfunc(key, buf, buffer_size)
467
 
            if not length:
468
 
                code = ctypes.GetLastError()
469
 
                if code == 203:  # ERROR_ENVVAR_NOT_FOUND
470
 
                    return default
471
 
                raise ctypes.WinError(code)
472
 
            if buffer_size > length:
473
 
                return buf[:length]
474
 
            buffer_size = length
475
 
 
476
 
 
477
 
if has_ctypes_win32:
478
 
    from ctypes.wintypes import BOOL, DWORD, HANDLE
479
 
    _kernel32 = ctypes.windll.kernel32
480
 
    _CloseHandle = ctypes.WINFUNCTYPE(BOOL, HANDLE)(
481
 
        ("CloseHandle", _kernel32))
482
 
    _OpenProcess = ctypes.WINFUNCTYPE(HANDLE, DWORD, BOOL, DWORD)(
483
 
        ("OpenProcess", _kernel32))
484
 
 
485
 
    def _ctypes_is_local_pid_dead(pid):
486
 
        """True if pid doesn't correspond to live process on this machine"""
487
 
        handle = _OpenProcess(1, False, pid)  # PROCESS_TERMINATE
488
 
        if not handle:
489
 
            errorcode = ctypes.GetLastError()
490
 
            if errorcode == 5:  # ERROR_ACCESS_DENIED
491
 
                # Probably something alive we're not allowed to kill
492
 
                return False
493
 
            elif errorcode == 87:  # ERROR_INVALID_PARAMETER
494
 
                return True
495
 
            raise ctypes.WinError(errorcode)
496
 
        _CloseHandle(handle)
497
 
        return False
498
 
 
499
 
    is_local_pid_dead = _ctypes_is_local_pid_dead
 
665
else:
 
666
    get_unicode_argv = None