~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

  • Committer: Robert Collins
  • Date: 2007-04-19 02:27:44 UTC
  • mto: This revision was merged to the branch mainline in revision 2426.
  • Revision ID: robertc@robertcollins.net-20070419022744-pfdqz42kp1wizh43
``make docs`` now creates a man page at ``man1/bzr.1`` fixing bug 107388.
(Robert Collins)

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': mem_struct.QuotaPeakNonPagedPoolUsage,
139
 
                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
140
 
                'PagefileUsage': mem_struct.PagefileUsage,
141
 
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
142
 
                'PrivateUsage': mem_struct.PrivateUsage,
143
 
               }
144
 
    elif has_win32api:
145
 
        import win32process
146
 
        # win32process does not return PrivateUsage, because it doesn't use
147
 
        # PROCESS_MEMORY_COUNTERS_EX (it uses the one without _EX).
148
 
        proc = win32process.GetCurrentProcess()
149
 
        info = win32process.GetProcessMemoryInfo(proc)
150
 
    else:
151
 
        trace.note('Cannot debug memory on win32 without ctypes'
152
 
                   ' or win32process')
153
 
        return
154
 
    if short:
155
 
        trace.note('WorkingSize %7dKB'
156
 
                   '\tPeakWorking %7dKB\t%s',
157
 
                   info['WorkingSetSize'] / 1024,
158
 
                   info['PeakWorkingSetSize'] / 1024,
159
 
                   message)
160
 
        return
161
 
    if message:
162
 
        trace.note('%s', message)
163
 
    trace.note('WorkingSize       %8d KB', info['WorkingSetSize'] / 1024)
164
 
    trace.note('PeakWorking       %8d KB', info['PeakWorkingSetSize'] / 1024)
165
 
    trace.note('PagefileUsage     %8d KB', info.get('PagefileUsage', 0) / 1024)
166
 
    trace.note('PeakPagefileUsage %8d KB', info.get('PeakPagefileUsage', 0) / 1024)
167
 
    trace.note('PrivateUsage      %8d KB', info.get('PrivateUsage', 0) / 1024)
168
 
    trace.note('PageFaultCount    %8d', info.get('PageFaultCount', 0))
169
 
 
170
84
 
171
85
def get_console_size(defaultx=80, defaulty=25):
172
86
    """Return size of current console.
180
94
        return (defaultx, defaulty)
181
95
 
182
96
    # To avoid problem with redirecting output via pipe
183
 
    # we need to use stderr instead of stdout
 
97
    # need to use stderr instead of stdout
184
98
    h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
185
99
    csbi = ctypes.create_string_buffer(22)
186
100
    res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
195
109
        return (defaultx, defaulty)
196
110
 
197
111
 
198
 
def _get_sh_special_folder_path(csidl):
199
 
    """Call SHGetSpecialFolderPathW if available, or return None.
200
 
 
201
 
    Result is always unicode (or None).
202
 
    """
203
 
    if has_ctypes:
204
 
        try:
205
 
            SHGetSpecialFolderPath = \
206
 
                ctypes.windll.shell32.SHGetSpecialFolderPathW
207
 
        except AttributeError:
208
 
            pass
209
 
        else:
210
 
            buf = ctypes.create_unicode_buffer(MAX_PATH)
211
 
            if SHGetSpecialFolderPath(None,buf,csidl,0):
212
 
                return buf.value
213
 
 
214
 
    global has_win32com_shell
215
 
    if has_win32com_shell is None:
216
 
        try:
217
 
            from win32com.shell import shell
218
 
            has_win32com_shell = True
219
 
        except ImportError:
220
 
            has_win32com_shell = False
221
 
    if has_win32com_shell:
222
 
        # still need to bind the name locally, but this is fast.
223
 
        from win32com.shell import shell
224
 
        try:
225
 
            return shell.SHGetSpecialFolderPath(0, csidl, 0)
226
 
        except shell.error:
227
 
            # possibly E_NOTIMPL meaning we can't load the function pointer,
228
 
            # or E_FAIL meaning the function failed - regardless, just ignore it
229
 
            pass
230
 
    return None
231
 
 
232
 
 
233
112
def get_appdata_location():
234
113
    """Return Application Data location.
235
114
    Return None if we cannot obtain location.
236
115
 
237
 
    Windows defines two 'Application Data' folders per user - a 'roaming'
238
 
    one that moves with the user as they logon to different machines, and
239
 
    a 'local' one that stays local to the machine.  This returns the 'roaming'
240
 
    directory, and thus is suitable for storing user-preferences, etc.
241
 
 
242
 
    Returned value can be unicode or plain string.
 
116
    Returned value can be unicode or plain sring.
243
117
    To convert plain string to unicode use
244
 
    s.decode(osutils.get_user_encoding())
245
 
    (XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
 
118
    s.decode(bzrlib.user_encoding)
246
119
    """
247
 
    appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
248
 
    if appdata:
249
 
        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
250
130
    # from env variable
251
131
    appdata = os.environ.get('APPDATA')
252
132
    if appdata:
262
142
    return None
263
143
 
264
144
 
265
 
def get_local_appdata_location():
266
 
    """Return Local Application Data location.
267
 
    Return the same as get_appdata_location() if we cannot obtain location.
268
 
 
269
 
    Windows defines two 'Application Data' folders per user - a 'roaming'
270
 
    one that moves with the user as they logon to different machines, and
271
 
    a 'local' one that stays local to the machine.  This returns the 'local'
272
 
    directory, and thus is suitable for caches, temp files and other things
273
 
    which don't need to move with the user.
274
 
 
275
 
    Returned value can be unicode or plain string.
276
 
    To convert plain string to unicode use
277
 
    s.decode(osutils.get_user_encoding())
278
 
    (XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
279
 
    """
280
 
    local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
281
 
    if local:
282
 
        return local
283
 
    # Vista supplies LOCALAPPDATA, but XP and earlier do not.
284
 
    local = os.environ.get('LOCALAPPDATA')
285
 
    if local:
286
 
        return local
287
 
    return get_appdata_location()
288
 
 
289
 
 
290
145
def get_home_location():
291
146
    """Return user's home location.
292
147
    Assume on win32 it's the <My Documents> folder.
293
148
    If location cannot be obtained return system drive root,
294
149
    i.e. C:\
295
150
 
296
 
    Returned value can be unicode or plain string.
 
151
    Returned value can be unicode or plain sring.
297
152
    To convert plain string to unicode use
298
 
    s.decode(osutils.get_user_encoding())
 
153
    s.decode(bzrlib.user_encoding)
299
154
    """
300
 
    home = _get_sh_special_folder_path(CSIDL_PERSONAL)
301
 
    if home:
302
 
        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
303
165
    # try for HOME env variable
304
166
    home = os.path.expanduser('~')
305
167
    if home != '~':
307
169
    # at least return windows root directory
308
170
    windir = os.environ.get('windir')
309
171
    if windir:
310
 
        return os.path.splitdrive(windir)[0] + '/'
 
172
        return os.path.splitdrive(windir) + '/'
311
173
    # otherwise C:\ is good enough for 98% users
312
174
    return 'C:/'
313
175
 
316
178
    """Return user name as login name.
317
179
    If name cannot be obtained return None.
318
180
 
319
 
    Returned value can be unicode or plain string.
 
181
    Returned value can be unicode or plain sring.
320
182
    To convert plain string to unicode use
321
 
    s.decode(osutils.get_user_encoding())
 
183
    s.decode(bzrlib.user_encoding)
322
184
    """
323
185
    if has_ctypes:
324
186
        try:
335
197
    return os.environ.get('USERNAME', None)
336
198
 
337
199
 
338
 
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
339
 
# computer or the cluster associated with the local computer."
340
 
_WIN32_ComputerNameDnsHostname = 1
341
 
 
342
200
def get_host_name():
343
201
    """Return host machine name.
344
202
    If name cannot be obtained return None.
345
203
 
346
 
    :return: A unicode string representing the host name. On win98, this may be
347
 
        a plain string as win32 api doesn't support unicode.
 
204
    Returned value can be unicode or plain sring.
 
205
    To convert plain string to unicode use
 
206
    s.decode(bzrlib.user_encoding)
348
207
    """
349
 
    if has_win32api:
350
 
        try:
351
 
            return win32api.GetComputerNameEx(_WIN32_ComputerNameDnsHostname)
352
 
        except (NotImplementedError, win32api.error):
353
 
            # NotImplemented will happen on win9x...
354
 
            pass
355
208
    if has_ctypes:
356
209
        try:
357
210
            kernel32 = ctypes.windll.kernel32
 
211
            GetComputerName = getattr(kernel32, 'GetComputerName'+suffix)
358
212
        except AttributeError:
359
 
            pass # Missing the module we need
 
213
            pass
360
214
        else:
361
215
            buf = create_buffer(MAX_COMPUTERNAME_LENGTH+1)
362
216
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
363
 
 
364
 
            # Try GetComputerNameEx which gives a proper Unicode hostname
365
 
            GetComputerNameEx = getattr(kernel32, 'GetComputerNameEx'+suffix,
366
 
                                        None)
367
 
            if (GetComputerNameEx is not None
368
 
                and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
369
 
                                      buf, ctypes.byref(n))):
370
 
                return buf.value
371
 
 
372
 
            # Try GetComputerName in case GetComputerNameEx wasn't found
373
 
            # It returns the NETBIOS name, which isn't as good, but still ok.
374
 
            # The first GetComputerNameEx might have changed 'n', so reset it
375
 
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
376
 
            GetComputerName = getattr(kernel32, 'GetComputerName'+suffix,
377
 
                                      None)
378
 
            if (GetComputerName is not None
379
 
                and GetComputerName(buf, ctypes.byref(n))):
380
 
                return buf.value
381
 
    # otherwise try env variables, which will be 'mbcs' encoded
382
 
    # on Windows (Python doesn't expose the native win32 unicode environment)
383
 
    # According to this:
384
 
    # http://msdn.microsoft.com/en-us/library/aa246807.aspx
385
 
    # environment variables should always be encoded in 'mbcs'.
386
 
    try:
387
 
        return os.environ['COMPUTERNAME'].decode("mbcs")
388
 
    except KeyError:
389
 
        return None
 
217
            if GetComputerName(buf, ctypes.byref(n)):
 
218
                return buf.value
 
219
    # otherwise try env variables
 
220
    return os.environ.get('COMPUTERNAME', None)
390
221
 
391
222
 
392
223
def _ensure_unicode(s):
393
224
    if s and type(s) != unicode:
394
 
        from bzrlib import osutils
395
 
        s = s.decode(osutils.get_user_encoding())
 
225
        import bzrlib
 
226
        s = s.decode(bzrlib.user_encoding)
396
227
    return s
397
 
 
 
228
    
398
229
 
399
230
def get_appdata_location_unicode():
400
231
    return _ensure_unicode(get_appdata_location())
407
238
 
408
239
def get_host_name_unicode():
409
240
    return _ensure_unicode(get_host_name())
410
 
 
411
 
 
412
 
def _ensure_with_dir(path):
413
 
    if not os.path.split(path)[0] or path.startswith(u'*') or path.startswith(u'?'):
414
 
        return u'./' + path, True
415
 
    else:
416
 
        return path, False
417
 
 
418
 
def _undo_ensure_with_dir(path, corrected):
419
 
    if corrected:
420
 
        return path[2:]
421
 
    else:
422
 
        return path
423
 
 
424
 
 
425
 
 
426
 
def glob_one(possible_glob):
427
 
    """Same as glob.glob().
428
 
 
429
 
    work around bugs in glob.glob()
430
 
    - Python bug #1001604 ("glob doesn't return unicode with ...")
431
 
    - failing expansion for */* with non-iso-8859-* chars
432
 
    """
433
 
    corrected_glob, corrected = _ensure_with_dir(possible_glob)
434
 
    glob_files = glob.glob(corrected_glob)
435
 
 
436
 
    if not glob_files:
437
 
        # special case to let the normal code path handle
438
 
        # files that do not exist, etc.
439
 
        glob_files = [possible_glob]
440
 
    elif corrected:
441
 
        glob_files = [_undo_ensure_with_dir(elem, corrected)
442
 
                      for elem in glob_files]
443
 
    return [elem.replace(u'\\', u'/') for elem in glob_files]
444
 
 
445
 
 
446
 
def glob_expand(file_list):
447
 
    """Replacement for glob expansion by the shell.
448
 
 
449
 
    Win32's cmd.exe does not do glob expansion (eg ``*.py``), so we do our own
450
 
    here.
451
 
 
452
 
    :param file_list: A list of filenames which may include shell globs.
453
 
    :return: An expanded list of filenames.
454
 
 
455
 
    Introduced in bzrlib 0.18.
456
 
    """
457
 
    if not file_list:
458
 
        return []
459
 
    expanded_file_list = []
460
 
    for possible_glob in file_list:
461
 
        expanded_file_list.extend(glob_one(possible_glob))
462
 
    return expanded_file_list
463
 
 
464
 
 
465
 
def get_app_path(appname):
466
 
    """Look up in Windows registry for full path to application executable.
467
 
    Typically, applications create subkey with their basename
468
 
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
469
 
 
470
 
    :param  appname:    name of application (if no filename extension
471
 
                        is specified, .exe used)
472
 
    :return:    full path to aplication executable from registry,
473
 
                or appname itself if nothing found.
474
 
    """
475
 
    import _winreg
476
 
 
477
 
    basename = appname
478
 
    if not os.path.splitext(basename)[1]:
479
 
        basename = appname + '.exe'
480
 
 
481
 
    try:
482
 
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
483
 
            'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
484
 
            basename)
485
 
    except EnvironmentError:
486
 
        return appname
487
 
 
488
 
    try:
489
 
        try:
490
 
            path, type_id = _winreg.QueryValueEx(hkey, '')
491
 
        except WindowsError:
492
 
            return appname
493
 
    finally:
494
 
        _winreg.CloseKey(hkey)
495
 
 
496
 
    if type_id == REG_SZ:
497
 
        return path
498
 
    if type_id == REG_EXPAND_SZ and has_win32api:
499
 
        fullpath = win32api.ExpandEnvironmentStrings(path)
500
 
        if len(fullpath) > 1 and fullpath[0] == '"' and fullpath[-1] == '"':
501
 
            fullpath = fullpath[1:-1]   # remove quotes around value
502
 
        return fullpath
503
 
    return appname
504
 
 
505
 
 
506
 
def set_file_attr_hidden(path):
507
 
    """Set file attributes to hidden if possible"""
508
 
    if has_win32file:
509
 
        if winver != 'Windows 98':
510
 
            SetFileAttributes = win32file.SetFileAttributesW
511
 
        else:
512
 
            SetFileAttributes = win32file.SetFileAttributes
513
 
        try:
514
 
            SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
515
 
        except pywintypes.error, e:
516
 
            from bzrlib import trace
517
 
            trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
518
 
 
519
 
 
520
 
 
521
 
class UnicodeShlex(object):
522
 
    """This is a very simplified version of shlex.shlex.
523
 
 
524
 
    The main change is that it supports non-ascii input streams. The internal
525
 
    structure is quite simplified relative to shlex.shlex, since we aren't
526
 
    trying to handle multiple input streams, etc. In fact, we don't use a
527
 
    file-like api either.
528
 
    """
529
 
 
530
 
    def __init__(self, uni_string):
531
 
        self._input = uni_string
532
 
        self._input_iter = iter(self._input)
533
 
        self._whitespace_match = re.compile(u'\s').match
534
 
        self._word_match = re.compile(u'\S').match
535
 
        self._quote_chars = u'"'
536
 
        # self._quote_match = re.compile(u'[\'"]').match
537
 
        self._escape_match = lambda x: None # Never matches
538
 
        self._escape = '\\'
539
 
        # State can be
540
 
        #   ' ' - after whitespace, starting a new token
541
 
        #   'a' - after text, currently working on a token
542
 
        #   '"' - after ", currently in a "-delimited quoted section
543
 
        #   "\" - after '\', checking the next char
544
 
        self._state = ' '
545
 
        self._token = [] # Current token being parsed
546
 
 
547
 
    def _get_token(self):
548
 
        # Were there quote chars as part of this token?
549
 
        quoted = False
550
 
        quoted_state = None
551
 
        for nextchar in self._input_iter:
552
 
            if self._state == ' ':
553
 
                if self._whitespace_match(nextchar):
554
 
                    # if self._token: return token
555
 
                    continue
556
 
                elif nextchar in self._quote_chars:
557
 
                    self._state = nextchar # quoted state
558
 
                elif self._word_match(nextchar):
559
 
                    self._token.append(nextchar)
560
 
                    self._state = 'a'
561
 
                else:
562
 
                    raise AssertionError('wtttf?')
563
 
            elif self._state in self._quote_chars:
564
 
                quoted = True
565
 
                if nextchar == self._state: # End of quote
566
 
                    self._state = 'a' # posix allows 'foo'bar to translate to
567
 
                                      # foobar
568
 
                elif self._state == '"' and nextchar == self._escape:
569
 
                    quoted_state = self._state
570
 
                    self._state = nextchar
571
 
                else:
572
 
                    self._token.append(nextchar)
573
 
            elif self._state == self._escape:
574
 
                if nextchar == '\\':
575
 
                    self._token.append('\\')
576
 
                elif nextchar == '"':
577
 
                    self._token.append(nextchar)
578
 
                else:
579
 
                    self._token.append('\\' + nextchar)
580
 
                self._state = quoted_state
581
 
            elif self._state == 'a':
582
 
                if self._whitespace_match(nextchar):
583
 
                    if self._token:
584
 
                        break # emit this token
585
 
                    else:
586
 
                        continue # no token to emit
587
 
                elif nextchar in self._quote_chars:
588
 
                    # Start a new quoted section
589
 
                    self._state = nextchar
590
 
                # escape?
591
 
                elif (self._word_match(nextchar)
592
 
                      or nextchar in self._quote_chars
593
 
                      # or whitespace_split?
594
 
                      ):
595
 
                    self._token.append(nextchar)
596
 
                else:
597
 
                    raise AssertionError('state == "a", char: %r'
598
 
                                         % (nextchar,))
599
 
            else:
600
 
                raise AssertionError('unknown state: %r' % (self._state,))
601
 
        result = ''.join(self._token)
602
 
        self._token = []
603
 
        if not quoted and result == '':
604
 
            result = None
605
 
        return quoted, result
606
 
 
607
 
    def __iter__(self):
608
 
        return self
609
 
 
610
 
    def next(self):
611
 
        quoted, token = self._get_token()
612
 
        if token is None:
613
 
            raise StopIteration
614
 
        return quoted, token
615
 
 
616
 
 
617
 
def _command_line_to_argv(command_line):
618
 
    """Convert a Unicode command line into a set of argv arguments.
619
 
 
620
 
    This does wildcard expansion, etc. It is intended to make wildcards act
621
 
    closer to how they work in posix shells, versus how they work by default on
622
 
    Windows.
623
 
    """
624
 
    s = UnicodeShlex(command_line)
625
 
    # Now that we've split the content, expand globs
626
 
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
627
 
    #       '**/' style globs
628
 
    args = []
629
 
    for is_quoted, arg in s:
630
 
        if is_quoted or not glob.has_magic(arg):
631
 
            args.append(arg)
632
 
        else:
633
 
            args.extend(glob_one(arg))
634
 
    return args
635
 
 
636
 
 
637
 
if has_ctypes and winver != 'Windows 98':
638
 
    def get_unicode_argv():
639
 
        LPCWSTR = ctypes.c_wchar_p
640
 
        INT = ctypes.c_int
641
 
        POINTER = ctypes.POINTER
642
 
        prototype = ctypes.WINFUNCTYPE(LPCWSTR)
643
 
        GetCommandLine = prototype(("GetCommandLineW",
644
 
                                    ctypes.windll.kernel32))
645
 
        prototype = ctypes.WINFUNCTYPE(POINTER(LPCWSTR), LPCWSTR, POINTER(INT))
646
 
        command_line = GetCommandLine()
647
 
        # Skip the first argument, since we only care about parameters
648
 
        argv = _command_line_to_argv(command_line)[1:]
649
 
        if getattr(sys, 'frozen', None) is None:
650
 
            # Invoked via 'python.exe' which takes the form:
651
 
            #   python.exe [PYTHON_OPTIONS] C:\Path\bzr [BZR_OPTIONS]
652
 
            # we need to get only BZR_OPTIONS part,
653
 
            # We already removed 'python.exe' so we remove everything up to and
654
 
            # including the first non-option ('-') argument.
655
 
            for idx in xrange(len(argv)):
656
 
                if argv[idx][:1] != '-':
657
 
                    break
658
 
            argv = argv[idx+1:]
659
 
        return argv
660
 
else:
661
 
    get_unicode_argv = None