~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

  • Committer: Daniel Watkins
  • Date: 2007-08-02 17:01:23 UTC
  • mto: This revision was merged to the branch mainline in revision 2669.
  • Revision ID: d.m.watkins@warwick.ac.uk-20070802170123-ymfewsc7w5kldit4
tests.blackbox.test_add now uses internals where appropriate.

Show diffs side-by-side

added added

removed removed

Lines of Context:
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Win32-specific helper functions
18
18
 
19
19
Only one dependency: ctypes should be installed.
20
20
"""
21
21
 
22
 
import glob
23
22
import os
24
 
import re
25
23
import struct
26
24
import sys
27
25
 
66
64
    else:
67
65
        create_buffer = ctypes.create_unicode_buffer
68
66
        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
67
 
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
68
 
86
69
# Special Win32 API constants
87
70
# Handles of std streams
91
74
 
92
75
# CSIDL constants (from MSDN 2003)
93
76
CSIDL_APPDATA = 0x001A      # Application Data folder
94
 
CSIDL_LOCAL_APPDATA = 0x001c# <user name>\Local Settings\Application Data (non roaming)
95
77
CSIDL_PERSONAL = 0x0005     # My Documents folder
96
78
 
97
79
# from winapi C headers
99
81
UNLEN = 256
100
82
MAX_COMPUTERNAME_LENGTH = 31
101
83
 
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
84
 
174
85
def get_console_size(defaultx=80, defaulty=25):
175
86
    """Return size of current console.
183
94
        return (defaultx, defaulty)
184
95
 
185
96
    # To avoid problem with redirecting output via pipe
186
 
    # we need to use stderr instead of stdout
 
97
    # need to use stderr instead of stdout
187
98
    h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
188
99
    csbi = ctypes.create_string_buffer(22)
189
100
    res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
190
101
 
191
102
    if res:
192
103
        (bufx, bufy, curx, cury, wattr,
193
 
        left, top, right, bottom, maxx, maxy) = struct.unpack(
194
 
            "hhhhHhhhhhh", csbi.raw)
 
104
        left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
195
105
        sizex = right - left + 1
196
106
        sizey = bottom - top + 1
197
107
        return (sizex, sizey)
199
109
        return (defaultx, defaulty)
200
110
 
201
111
 
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
112
def get_appdata_location():
238
113
    """Return Application Data location.
239
114
    Return None if we cannot obtain location.
240
115
 
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.
 
116
    Returned value can be unicode or plain sring.
247
117
    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')
 
118
    s.decode(bzrlib.user_encoding)
250
119
    """
251
 
    appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
252
 
    if appdata:
253
 
        return appdata
 
120
    if has_ctypes:
 
121
        try:
 
122
            SHGetSpecialFolderPath = \
 
123
                ctypes.windll.shell32.SHGetSpecialFolderPathW
 
124
        except AttributeError:
 
125
            pass
 
126
        else:
 
127
            buf = ctypes.create_unicode_buffer(MAX_PATH)
 
128
            if SHGetSpecialFolderPath(None,buf,CSIDL_APPDATA,0):
 
129
                return buf.value
254
130
    # from env variable
255
131
    appdata = os.environ.get('APPDATA')
256
132
    if appdata:
266
142
    return None
267
143
 
268
144
 
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
145
def get_home_location():
295
146
    """Return user's home location.
296
147
    Assume on win32 it's the <My Documents> folder.
297
148
    If location cannot be obtained return system drive root,
298
149
    i.e. C:\
299
150
 
300
 
    Returned value can be unicode or plain string.
 
151
    Returned value can be unicode or plain sring.
301
152
    To convert plain string to unicode use
302
 
    s.decode(osutils.get_user_encoding())
 
153
    s.decode(bzrlib.user_encoding)
303
154
    """
304
 
    home = _get_sh_special_folder_path(CSIDL_PERSONAL)
305
 
    if home:
306
 
        return home
 
155
    if has_ctypes:
 
156
        try:
 
157
            SHGetSpecialFolderPath = \
 
158
                ctypes.windll.shell32.SHGetSpecialFolderPathW
 
159
        except AttributeError:
 
160
            pass
 
161
        else:
 
162
            buf = ctypes.create_unicode_buffer(MAX_PATH)
 
163
            if SHGetSpecialFolderPath(None,buf,CSIDL_PERSONAL,0):
 
164
                return buf.value
307
165
    # try for HOME env variable
308
166
    home = os.path.expanduser('~')
309
167
    if home != '~':
320
178
    """Return user name as login name.
321
179
    If name cannot be obtained return None.
322
180
 
323
 
    Returned value can be unicode or plain string.
 
181
    Returned value can be unicode or plain sring.
324
182
    To convert plain string to unicode use
325
 
    s.decode(osutils.get_user_encoding())
 
183
    s.decode(bzrlib.user_encoding)
326
184
    """
327
185
    if has_ctypes:
328
186
        try:
339
197
    return os.environ.get('USERNAME', None)
340
198
 
341
199
 
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
200
def get_host_name():
347
201
    """Return host machine name.
348
202
    If name cannot be obtained return None.
349
203
 
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.
 
204
    Returned value can be unicode or plain sring.
 
205
    To convert plain string to unicode use
 
206
    s.decode(bzrlib.user_encoding)
352
207
    """
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
208
    if has_ctypes:
360
209
        try:
361
210
            kernel32 = ctypes.windll.kernel32
 
211
            GetComputerName = getattr(kernel32, 'GetComputerName'+suffix)
362
212
        except AttributeError:
363
 
            pass # Missing the module we need
 
213
            pass
364
214
        else:
365
215
            buf = create_buffer(MAX_COMPUTERNAME_LENGTH+1)
366
216
            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
 
217
            if GetComputerName(buf, ctypes.byref(n)):
 
218
                return buf.value
 
219
    # otherwise try env variables
 
220
    return os.environ.get('COMPUTERNAME', None)
394
221
 
395
222
 
396
223
def _ensure_unicode(s):
397
224
    if s and type(s) != unicode:
398
 
        from bzrlib import osutils
399
 
        s = s.decode(osutils.get_user_encoding())
 
225
        import bzrlib
 
226
        s = s.decode(bzrlib.user_encoding)
400
227
    return s
401
 
 
 
228
    
402
229
 
403
230
def get_appdata_location_unicode():
404
231
    return _ensure_unicode(get_appdata_location())
414
241
 
415
242
 
416
243
def _ensure_with_dir(path):
417
 
    if (not os.path.split(path)[0] or path.startswith(u'*')
418
 
        or path.startswith(u'?')):
 
244
    if not os.path.split(path)[0] or path.startswith(u'*') or path.startswith(u'?'):
419
245
        return u'./' + path, True
420
246
    else:
421
247
        return path, False
422
 
 
 
248
    
423
249
def _undo_ensure_with_dir(path, corrected):
424
250
    if corrected:
425
251
        return path[2:]
428
254
 
429
255
 
430
256
 
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
257
def glob_expand(file_list):
452
258
    """Replacement for glob expansion by the shell.
453
259
 
461
267
    """
462
268
    if not file_list:
463
269
        return []
 
270
    import glob
464
271
    expanded_file_list = []
465
272
    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
 
    """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
 
 
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
631
 
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
632
 
    #       '**/' style globs
633
 
    args = []
634
 
    for is_quoted, arg in s:
635
 
        if is_quoted or not glob.has_magic(arg):
636
 
            args.append(arg)
637
 
        else:
638
 
            args.extend(glob_one(arg))
639
 
    return args
640
 
 
641
 
 
642
 
if has_ctypes and winver != 'Windows 98':
643
 
    def get_unicode_argv():
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()
652
 
        # Skip the first argument, since we only care about parameters
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:]
664
 
        return argv
665
 
else:
666
 
    get_unicode_argv = None
 
273
        
 
274
        # work around bugs in glob.glob()
 
275
        # - Python bug #1001604 ("glob doesn't return unicode with ...")
 
276
        # - failing expansion for */* with non-iso-8859-* chars
 
277
        possible_glob, corrected = _ensure_with_dir(possible_glob)
 
278
        glob_files = glob.glob(possible_glob)
 
279
 
 
280
        if glob_files == []:
 
281
            # special case to let the normal code path handle
 
282
            # files that do not exists
 
283
            expanded_file_list.append(
 
284
                _undo_ensure_with_dir(possible_glob, corrected))
 
285
        else:
 
286
            glob_files = [_undo_ensure_with_dir(elem, corrected) for elem in glob_files]
 
287
            expanded_file_list += glob_files
 
288
            
 
289
    return [elem.replace(u'\\', u'/') for elem in expanded_file_list]