~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

Merge bzr.dev to resolve conflicts

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005-2010 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
"""Win32-specific helper functions
 
18
 
 
19
Only one dependency: ctypes should be installed.
 
20
"""
 
21
 
 
22
import glob
 
23
import os
 
24
import struct
 
25
import sys
 
26
 
 
27
from bzrlib import cmdline
 
28
 
 
29
# Windows version
 
30
if sys.platform == 'win32':
 
31
    _major,_minor,_build,_platform,_text = sys.getwindowsversion()
 
32
    # from MSDN:
 
33
    # dwPlatformId
 
34
    #   The operating system platform.
 
35
    #   This member can be one of the following values.
 
36
    #   ==========================  ======================================
 
37
    #   Value                       Meaning
 
38
    #   --------------------------  --------------------------------------
 
39
    #   VER_PLATFORM_WIN32_NT       The operating system is Windows Vista,
 
40
    #   2                           Windows Server "Longhorn",
 
41
    #                               Windows Server 2003, Windows XP,
 
42
    #                               Windows 2000, or Windows NT.
 
43
    #
 
44
    #   VER_PLATFORM_WIN32_WINDOWS  The operating system is Windows Me,
 
45
    #   1                           Windows 98, or Windows 95.
 
46
    #   ==========================  ======================================
 
47
    if _platform == 2:
 
48
        winver = 'Windows NT'
 
49
    else:
 
50
        # don't care about real Windows name, just to force safe operations
 
51
        winver = 'Windows 98'
 
52
else:
 
53
    winver = None
 
54
 
 
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...
 
85
 
 
86
# Special Win32 API constants
 
87
# Handles of std streams
 
88
WIN32_STDIN_HANDLE = -10
 
89
WIN32_STDOUT_HANDLE = -11
 
90
WIN32_STDERR_HANDLE = -12
 
91
 
 
92
# CSIDL constants (from MSDN 2003)
 
93
CSIDL_APPDATA = 0x001A      # Application Data folder
 
94
CSIDL_LOCAL_APPDATA = 0x001c# <user name>\Local Settings\Application Data (non roaming)
 
95
CSIDL_PERSONAL = 0x0005     # My Documents folder
 
96
 
 
97
# from winapi C headers
 
98
MAX_PATH = 260
 
99
UNLEN = 256
 
100
MAX_COMPUTERNAME_LENGTH = 31
 
101
 
 
102
# Registry data type ids
 
103
REG_SZ = 1
 
104
REG_EXPAND_SZ = 2
 
105
 
 
106
 
 
107
def debug_memory_win32api(message='', short=True):
 
108
    """Use trace.note() to dump the running memory info."""
 
109
    from bzrlib import trace
 
110
    if has_ctypes:
 
111
        class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
 
112
            """Used by GetProcessMemoryInfo"""
 
113
            _fields_ = [('cb', ctypes.c_ulong),
 
114
                        ('PageFaultCount', ctypes.c_ulong),
 
115
                        ('PeakWorkingSetSize', ctypes.c_size_t),
 
116
                        ('WorkingSetSize', ctypes.c_size_t),
 
117
                        ('QuotaPeakPagedPoolUsage', ctypes.c_size_t),
 
118
                        ('QuotaPagedPoolUsage', ctypes.c_size_t),
 
119
                        ('QuotaPeakNonPagedPoolUsage', ctypes.c_size_t),
 
120
                        ('QuotaNonPagedPoolUsage', ctypes.c_size_t),
 
121
                        ('PagefileUsage', ctypes.c_size_t),
 
122
                        ('PeakPagefileUsage', ctypes.c_size_t),
 
123
                        ('PrivateUsage', ctypes.c_size_t),
 
124
                       ]
 
125
        cur_process = ctypes.windll.kernel32.GetCurrentProcess()
 
126
        mem_struct = PROCESS_MEMORY_COUNTERS_EX()
 
127
        ret = ctypes.windll.psapi.GetProcessMemoryInfo(cur_process,
 
128
            ctypes.byref(mem_struct),
 
129
            ctypes.sizeof(mem_struct))
 
130
        if not ret:
 
131
            trace.note('Failed to GetProcessMemoryInfo()')
 
132
            return
 
133
        info = {'PageFaultCount': mem_struct.PageFaultCount,
 
134
                'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
 
135
                'WorkingSetSize': mem_struct.WorkingSetSize,
 
136
                'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
 
137
                'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
 
138
                'QuotaPeakNonPagedPoolUsage':
 
139
                    mem_struct.QuotaPeakNonPagedPoolUsage,
 
140
                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
 
141
                'PagefileUsage': mem_struct.PagefileUsage,
 
142
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
 
143
                '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)
 
151
    else:
 
152
        trace.note('Cannot debug memory on win32 without ctypes'
 
153
                   ' or win32process')
 
154
        return
 
155
    if short:
 
156
        # using base-2 units (see HACKING.txt).
 
157
        trace.note('WorkingSize %7dKiB'
 
158
                   '\tPeakWorking %7dKiB\t%s',
 
159
                   info['WorkingSetSize'] / 1024,
 
160
                   info['PeakWorkingSetSize'] / 1024,
 
161
                   message)
 
162
        return
 
163
    if message:
 
164
        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',
 
169
               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))
 
172
 
 
173
 
 
174
def get_console_size(defaultx=80, defaulty=25):
 
175
    """Return size of current console.
 
176
 
 
177
    This function try to determine actual size of current working
 
178
    console window and return tuple (sizex, sizey) if success,
 
179
    or default size (defaultx, defaulty) otherwise.
 
180
    """
 
181
    if not has_ctypes:
 
182
        # no ctypes is found
 
183
        return (defaultx, defaulty)
 
184
 
 
185
    # To avoid problem with redirecting output via pipe
 
186
    # we need to use stderr instead of stdout
 
187
    h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
 
188
    csbi = ctypes.create_string_buffer(22)
 
189
    res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
 
190
 
 
191
    if res:
 
192
        (bufx, bufy, curx, cury, wattr,
 
193
        left, top, right, bottom, maxx, maxy) = struct.unpack(
 
194
            "hhhhHhhhhhh", csbi.raw)
 
195
        sizex = right - left + 1
 
196
        sizey = bottom - top + 1
 
197
        return (sizex, sizey)
 
198
    else:
 
199
        return (defaultx, defaulty)
 
200
 
 
201
 
 
202
def _get_sh_special_folder_path(csidl):
 
203
    """Call SHGetSpecialFolderPathW if available, or return None.
 
204
 
 
205
    Result is always unicode (or None).
 
206
    """
 
207
    if has_ctypes:
 
208
        try:
 
209
            SHGetSpecialFolderPath = \
 
210
                ctypes.windll.shell32.SHGetSpecialFolderPathW
 
211
        except AttributeError:
 
212
            pass
 
213
        else:
 
214
            buf = ctypes.create_unicode_buffer(MAX_PATH)
 
215
            if SHGetSpecialFolderPath(None,buf,csidl,0):
 
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
 
234
    return None
 
235
 
 
236
 
 
237
def get_appdata_location():
 
238
    """Return Application Data location.
 
239
    Return None if we cannot obtain location.
 
240
 
 
241
    Windows defines two 'Application Data' folders per user - a 'roaming'
 
242
    one that moves with the user as they logon to different machines, and
 
243
    a 'local' one that stays local to the machine.  This returns the 'roaming'
 
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')
 
250
    """
 
251
    appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
 
252
    if appdata:
 
253
        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
 
267
 
 
268
 
 
269
def get_local_appdata_location():
 
270
    """Return Local Application Data location.
 
271
    Return the same as get_appdata_location() if we cannot obtain location.
 
272
 
 
273
    Windows defines two 'Application Data' folders per user - a 'roaming'
 
274
    one that moves with the user as they logon to different machines, and
 
275
    a 'local' one that stays local to the machine.  This returns the 'local'
 
276
    directory, and thus is suitable for caches, temp files and other things
 
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')
 
283
    """
 
284
    local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
 
285
    if local:
 
286
        return local
 
287
    # Vista supplies LOCALAPPDATA, but XP and earlier do not.
 
288
    local = os.environ.get('LOCALAPPDATA')
 
289
    if local:
 
290
        return local
 
291
    return get_appdata_location()
 
292
 
 
293
 
 
294
def get_home_location():
 
295
    """Return user's home location.
 
296
    Assume on win32 it's the <My Documents> folder.
 
297
    If location cannot be obtained return system drive root,
 
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())
 
303
    """
 
304
    home = _get_sh_special_folder_path(CSIDL_PERSONAL)
 
305
    if home:
 
306
        return home
 
307
    # try for HOME env variable
 
308
    home = os.path.expanduser('~')
 
309
    if home != '~':
 
310
        return home
 
311
    # at least return windows root directory
 
312
    windir = os.environ.get('windir')
 
313
    if windir:
 
314
        return os.path.splitdrive(windir)[0] + '/'
 
315
    # otherwise C:\ is good enough for 98% users
 
316
    return 'C:/'
 
317
 
 
318
 
 
319
def get_user_name():
 
320
    """Return user name as login name.
 
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())
 
326
    """
 
327
    if has_ctypes:
 
328
        try:
 
329
            advapi32 = ctypes.windll.advapi32
 
330
            GetUserName = getattr(advapi32, 'GetUserName'+suffix)
 
331
        except AttributeError:
 
332
            pass
 
333
        else:
 
334
            buf = create_buffer(UNLEN+1)
 
335
            n = ctypes.c_int(UNLEN+1)
 
336
            if GetUserName(buf, ctypes.byref(n)):
 
337
                return buf.value
 
338
    # otherwise try env variables
 
339
    return os.environ.get('USERNAME', None)
 
340
 
 
341
 
 
342
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
 
343
# computer or the cluster associated with the local computer."
 
344
_WIN32_ComputerNameDnsHostname = 1
 
345
 
 
346
def get_host_name():
 
347
    """Return host machine name.
 
348
    If name cannot be obtained return None.
 
349
 
 
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.
 
352
    """
 
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:
 
360
        try:
 
361
            kernel32 = ctypes.windll.kernel32
 
362
        except AttributeError:
 
363
            pass # Missing the module we need
 
364
        else:
 
365
            buf = create_buffer(MAX_COMPUTERNAME_LENGTH+1)
 
366
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
 
367
 
 
368
            # Try GetComputerNameEx which gives a proper Unicode hostname
 
369
            GetComputerNameEx = getattr(kernel32, 'GetComputerNameEx'+suffix,
 
370
                                        None)
 
371
            if (GetComputerNameEx is not None
 
372
                and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
 
373
                                      buf, ctypes.byref(n))):
 
374
                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())
 
414
 
 
415
 
 
416
def _ensure_with_dir(path):
 
417
    if (not os.path.split(path)[0] or path.startswith(u'*')
 
418
        or path.startswith(u'?')):
 
419
        return u'./' + path, True
 
420
    else:
 
421
        return path, False
 
422
 
 
423
def _undo_ensure_with_dir(path, corrected):
 
424
    if corrected:
 
425
        return path[2:]
 
426
    else:
 
427
        return path
 
428
 
 
429
 
 
430
 
 
431
def glob_one(possible_glob):
 
432
    """Same as glob.glob().
 
433
 
 
434
    work around bugs in glob.glob()
 
435
    - Python bug #1001604 ("glob doesn't return unicode with ...")
 
436
    - failing expansion for */* with non-iso-8859-* chars
 
437
    """
 
438
    corrected_glob, corrected = _ensure_with_dir(possible_glob)
 
439
    glob_files = glob.glob(corrected_glob)
 
440
 
 
441
    if not glob_files:
 
442
        # special case to let the normal code path handle
 
443
        # files that do not exist, etc.
 
444
        glob_files = [possible_glob]
 
445
    elif corrected:
 
446
        glob_files = [_undo_ensure_with_dir(elem, corrected)
 
447
                      for elem in glob_files]
 
448
    return [elem.replace(u'\\', u'/') for elem in glob_files]
 
449
 
 
450
 
 
451
def glob_expand(file_list):
 
452
    """Replacement for glob expansion by the shell.
 
453
 
 
454
    Win32's cmd.exe does not do glob expansion (eg ``*.py``), so we do our own
 
455
    here.
 
456
 
 
457
    :param file_list: A list of filenames which may include shell globs.
 
458
    :return: An expanded list of filenames.
 
459
 
 
460
    Introduced in bzrlib 0.18.
 
461
    """
 
462
    if not file_list:
 
463
        return []
 
464
    expanded_file_list = []
 
465
    for possible_glob in file_list:
 
466
        expanded_file_list.extend(glob_one(possible_glob))
 
467
    return expanded_file_list
 
468
 
 
469
 
 
470
def get_app_path(appname):
 
471
    r"""Look up in Windows registry for full path to application executable.
 
472
    Typically, applications create subkey with their basename
 
473
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
 
474
 
 
475
    :param  appname:    name of application (if no filename extension
 
476
                        is specified, .exe used)
 
477
    :return:    full path to aplication executable from registry,
 
478
                or appname itself if nothing found.
 
479
    """
 
480
    import _winreg
 
481
 
 
482
    basename = appname
 
483
    if not os.path.splitext(basename)[1]:
 
484
        basename = appname + '.exe'
 
485
 
 
486
    try:
 
487
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
 
488
            'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
 
489
            basename)
 
490
    except EnvironmentError:
 
491
        return appname
 
492
 
 
493
    try:
 
494
        try:
 
495
            path, type_id = _winreg.QueryValueEx(hkey, '')
 
496
        except WindowsError:
 
497
            return appname
 
498
    finally:
 
499
        _winreg.CloseKey(hkey)
 
500
 
 
501
    if type_id == REG_SZ:
 
502
        return path
 
503
    if type_id == REG_EXPAND_SZ and has_win32api:
 
504
        fullpath = win32api.ExpandEnvironmentStrings(path)
 
505
        if len(fullpath) > 1 and fullpath[0] == '"' and fullpath[-1] == '"':
 
506
            fullpath = fullpath[1:-1]   # remove quotes around value
 
507
        return fullpath
 
508
    return appname
 
509
 
 
510
 
 
511
def set_file_attr_hidden(path):
 
512
    """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, argv, single_quotes_allowed=False):
 
526
    """Convert a Unicode command line into a list of argv arguments.
 
527
 
 
528
    It performs wildcard expansion to make wildcards act closer to how they
 
529
    work in posix shells, versus how they work by default on Windows. Quoted
 
530
    arguments are left untouched.
 
531
 
 
532
    :param command_line: The unicode string to split into an arg list.
 
533
    :param single_quotes_allowed: Whether single quotes are accepted as quoting
 
534
                                  characters like double quotes. False by
 
535
                                  default.
 
536
    :return: A list of unicode strings.
 
537
    """
 
538
    # First, spit the command line
 
539
    s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
 
540
    
 
541
    # Bug #587868 Now make sure that the length of s agrees with sys.argv 
 
542
    # we do this by simply counting the number of arguments in each. The counts should 
 
543
    # agree no matter what encoding sys.argv is in (AFAIK) 
 
544
    # len(arguments) < len(sys.argv) should be an impossibility since python gets 
 
545
    # args from the very same PEB as does GetCommandLineW
 
546
    arguments = list(s)
 
547
    
 
548
    # Now shorten the command line we get from GetCommandLineW to match sys.argv
 
549
    if len(arguments) < len(argv):
 
550
        raise AssertionError("Split command line can't be shorter than argv")
 
551
    arguments = arguments[len(arguments) - len(argv):]
 
552
    
 
553
    # Carry on to process globs (metachars) in the command line
 
554
    # expand globs if necessary
 
555
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
 
556
    #       '**/' style globs
 
557
    args = []
 
558
    for is_quoted, arg in arguments:
 
559
        if is_quoted or not glob.has_magic(arg):
 
560
            args.append(arg)
 
561
        else:
 
562
            args.extend(glob_one(arg))
 
563
    return args
 
564
 
 
565
 
 
566
if has_ctypes and winver != 'Windows 98':
 
567
    def get_unicode_argv():
 
568
        prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
 
569
        GetCommandLineW = prototype(("GetCommandLineW",
 
570
                                     ctypes.windll.kernel32))
 
571
        command_line = GetCommandLineW()
 
572
        if command_line is None:
 
573
            raise ctypes.WinError()
 
574
        # Skip the first argument, since we only care about parameters
 
575
        argv = _command_line_to_argv(command_line, sys.argv)[1:]
 
576
        return argv
 
577
else:
 
578
    get_unicode_argv = None