← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

  • Committer: John Arbash Meinel
  • Date: 2008-07-09 21:42:24 UTC
  • mto: This revision was merged to the branch mainline in revision 3543.
  • Revision ID: john@arbash-meinel.com-20080709214224-r75k87r6a01pfc3h
Restore a real weave merge to 'bzr merge --weave'.

To do so efficiently, we only add the simple LCAs to the final weave
object, unless we run into complexities with the merge graph.
This gives the same effective result as adding all the texts,
with the advantage of not having to extract all of them.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/win32utils.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
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
 
from __future__ import absolute_import
23
 
 
24
 
import glob
25
 
import operator
26
22
import os
27
23
import struct
28
24
import sys
29
25
 
30
 
from bzrlib import (
31
 
    cmdline,
32
 
    symbol_versioning,
33
 
    )
34
 
from bzrlib.i18n import gettext
35
26
 
36
27
# Windows version
37
28
if sys.platform == 'win32':
69
60
else:
70
61
    if winver == 'Windows 98':
71
62
        create_buffer = ctypes.create_string_buffer
72
 
        def extract_buffer(buf):
73
 
            return buf.value.decode("mbcs")
74
63
        suffix = 'A'
75
64
    else:
76
65
        create_buffer = ctypes.create_unicode_buffer
77
 
        extract_buffer = operator.attrgetter("value")
78
66
        suffix = 'W'
79
67
try:
80
 
    import pywintypes
81
 
    has_pywintypes = True
 
68
    import win32file
 
69
    has_win32file = True
82
70
except ImportError:
83
 
    has_pywintypes = has_win32file = has_win32api = False
84
 
else:
85
 
    try:
86
 
        import win32file
87
 
        has_win32file = True
88
 
    except ImportError:
89
 
        has_win32file = False
90
 
    try:
91
 
        import win32api
92
 
        has_win32api = True
93
 
    except ImportError:
94
 
        has_win32api = False
 
71
    has_win32file = False
95
72
 
96
 
# pulling in win32com.shell is a bit of overhead, and normally we don't need
97
 
# it as ctypes is preferred and common.  lazy_imports and "optional"
98
 
# modules don't work well, so we do our own lazy thing...
99
 
has_win32com_shell = None # Set to True or False once we know for sure...
100
73
 
101
74
# Special Win32 API constants
102
75
# Handles of std streams
106
79
 
107
80
# CSIDL constants (from MSDN 2003)
108
81
CSIDL_APPDATA = 0x001A      # Application Data folder
109
 
CSIDL_LOCAL_APPDATA = 0x001c# <user name>\Local Settings\Application Data (non roaming)
110
82
CSIDL_PERSONAL = 0x0005     # My Documents folder
111
83
 
112
84
# from winapi C headers
114
86
UNLEN = 256
115
87
MAX_COMPUTERNAME_LENGTH = 31
116
88
 
117
 
# Registry data type ids
118
 
REG_SZ = 1
119
 
REG_EXPAND_SZ = 2
120
 
 
121
 
 
122
 
def debug_memory_win32api(message='', short=True):
123
 
    """Use trace.note() to dump the running memory info."""
124
 
    from bzrlib import trace
125
 
    if has_ctypes:
126
 
        class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
127
 
            """Used by GetProcessMemoryInfo"""
128
 
            _fields_ = [('cb', ctypes.c_ulong),
129
 
                        ('PageFaultCount', ctypes.c_ulong),
130
 
                        ('PeakWorkingSetSize', ctypes.c_size_t),
131
 
                        ('WorkingSetSize', ctypes.c_size_t),
132
 
                        ('QuotaPeakPagedPoolUsage', ctypes.c_size_t),
133
 
                        ('QuotaPagedPoolUsage', ctypes.c_size_t),
134
 
                        ('QuotaPeakNonPagedPoolUsage', ctypes.c_size_t),
135
 
                        ('QuotaNonPagedPoolUsage', ctypes.c_size_t),
136
 
                        ('PagefileUsage', ctypes.c_size_t),
137
 
                        ('PeakPagefileUsage', ctypes.c_size_t),
138
 
                        ('PrivateUsage', ctypes.c_size_t),
139
 
                       ]
140
 
        cur_process = ctypes.windll.kernel32.GetCurrentProcess()
141
 
        mem_struct = PROCESS_MEMORY_COUNTERS_EX()
142
 
        ret = ctypes.windll.psapi.GetProcessMemoryInfo(cur_process,
143
 
            ctypes.byref(mem_struct),
144
 
            ctypes.sizeof(mem_struct))
145
 
        if not ret:
146
 
            trace.note(gettext('Failed to GetProcessMemoryInfo()'))
147
 
            return
148
 
        info = {'PageFaultCount': mem_struct.PageFaultCount,
149
 
                'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
150
 
                'WorkingSetSize': mem_struct.WorkingSetSize,
151
 
                'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
152
 
                'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
153
 
                'QuotaPeakNonPagedPoolUsage':
154
 
                    mem_struct.QuotaPeakNonPagedPoolUsage,
155
 
                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
156
 
                'PagefileUsage': mem_struct.PagefileUsage,
157
 
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
158
 
                'PrivateUsage': mem_struct.PrivateUsage,
159
 
               }
160
 
    elif has_win32api:
161
 
        import win32process
162
 
        # win32process does not return PrivateUsage, because it doesn't use
163
 
        # PROCESS_MEMORY_COUNTERS_EX (it uses the one without _EX).
164
 
        proc = win32process.GetCurrentProcess()
165
 
        info = win32process.GetProcessMemoryInfo(proc)
166
 
    else:
167
 
        trace.note(gettext('Cannot debug memory on win32 without ctypes'
168
 
                   ' or win32process'))
169
 
        return
170
 
    if short:
171
 
        # using base-2 units (see HACKING.txt).
172
 
        trace.note(gettext('WorkingSize {0:>7}KiB'
173
 
                   '\tPeakWorking {1:>7}KiB\t{2}').format(
174
 
                   info['WorkingSetSize'] / 1024,
175
 
                   info['PeakWorkingSetSize'] / 1024,
176
 
                   message))
177
 
        return
178
 
    if message:
179
 
        trace.note('%s', message)
180
 
    trace.note(gettext('WorkingSize       %8d KiB'), info['WorkingSetSize'] / 1024)
181
 
    trace.note(gettext('PeakWorking       %8d KiB'), info['PeakWorkingSetSize'] / 1024)
182
 
    trace.note(gettext('PagefileUsage     %8d KiB'), info.get('PagefileUsage', 0) / 1024)
183
 
    trace.note(gettext('PeakPagefileUsage %8d KiB'),
184
 
               info.get('PeakPagefileUsage', 0) / 1024)
185
 
    trace.note(gettext('PrivateUsage      %8d KiB'), info.get('PrivateUsage', 0) / 1024)
186
 
    trace.note(gettext('PageFaultCount    %8d'), info.get('PageFaultCount', 0))
187
 
 
188
89
 
189
90
def get_console_size(defaultx=80, defaulty=25):
190
91
    """Return size of current console.
198
99
        return (defaultx, defaulty)
199
100
 
200
101
    # To avoid problem with redirecting output via pipe
201
 
    # we need to use stderr instead of stdout
 
102
    # need to use stderr instead of stdout
202
103
    h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
203
104
    csbi = ctypes.create_string_buffer(22)
204
105
    res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
205
106
 
206
107
    if res:
207
108
        (bufx, bufy, curx, cury, wattr,
208
 
        left, top, right, bottom, maxx, maxy) = struct.unpack(
209
 
            "hhhhHhhhhhh", csbi.raw)
 
109
        left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
210
110
        sizex = right - left + 1
211
111
        sizey = bottom - top + 1
212
112
        return (sizex, sizey)
214
114
        return (defaultx, defaulty)
215
115
 
216
116
 
217
 
def _get_sh_special_folder_path(csidl):
218
 
    """Call SHGetSpecialFolderPathW if available, or return None.
219
 
 
220
 
    Result is always unicode (or None).
221
 
    """
222
 
    if has_ctypes:
223
 
        try:
224
 
            SHGetSpecialFolderPath = \
225
 
                ctypes.windll.shell32.SHGetSpecialFolderPathW
226
 
        except AttributeError:
227
 
            pass
228
 
        else:
229
 
            buf = ctypes.create_unicode_buffer(MAX_PATH)
230
 
            if SHGetSpecialFolderPath(None,buf,csidl,0):
231
 
                return buf.value
232
 
 
233
 
    global has_win32com_shell
234
 
    if has_win32com_shell is None:
235
 
        try:
236
 
            from win32com.shell import shell
237
 
            has_win32com_shell = True
238
 
        except ImportError:
239
 
            has_win32com_shell = False
240
 
    if has_win32com_shell:
241
 
        # still need to bind the name locally, but this is fast.
242
 
        from win32com.shell import shell
243
 
        try:
244
 
            return shell.SHGetSpecialFolderPath(0, csidl, 0)
245
 
        except shell.error:
246
 
            # possibly E_NOTIMPL meaning we can't load the function pointer,
247
 
            # or E_FAIL meaning the function failed - regardless, just ignore it
248
 
            pass
249
 
    return None
250
 
 
251
 
 
252
117
def get_appdata_location():
253
118
    """Return Application Data location.
254
119
    Return None if we cannot obtain location.
255
120
 
256
 
    Windows defines two 'Application Data' folders per user - a 'roaming'
257
 
    one that moves with the user as they logon to different machines, and
258
 
    a 'local' one that stays local to the machine.  This returns the 'roaming'
259
 
    directory, and thus is suitable for storing user-preferences, etc.
 
121
    Returned value can be unicode or plain sring.
 
122
    To convert plain string to unicode use
 
123
    s.decode(bzrlib.user_encoding)
260
124
    """
261
 
    appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
 
125
    if has_ctypes:
 
126
        try:
 
127
            SHGetSpecialFolderPath = \
 
128
                ctypes.windll.shell32.SHGetSpecialFolderPathW
 
129
        except AttributeError:
 
130
            pass
 
131
        else:
 
132
            buf = ctypes.create_unicode_buffer(MAX_PATH)
 
133
            if SHGetSpecialFolderPath(None,buf,CSIDL_APPDATA,0):
 
134
                return buf.value
 
135
    # from env variable
 
136
    appdata = os.environ.get('APPDATA')
262
137
    if appdata:
263
138
        return appdata
264
 
    # Use APPDATA if defined, will return None if not
265
 
    return get_environ_unicode('APPDATA')
266
 
 
267
 
 
268
 
def get_local_appdata_location():
269
 
    """Return Local Application Data location.
270
 
    Return the same as get_appdata_location() if we cannot obtain location.
271
 
 
272
 
    Windows defines two 'Application Data' folders per user - a 'roaming'
273
 
    one that moves with the user as they logon to different machines, and
274
 
    a 'local' one that stays local to the machine.  This returns the 'local'
275
 
    directory, and thus is suitable for caches, temp files and other things
276
 
    which don't need to move with the user.
277
 
    """
278
 
    local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
279
 
    if local:
280
 
        return local
281
 
    # Vista supplies LOCALAPPDATA, but XP and earlier do not.
282
 
    local = get_environ_unicode('LOCALAPPDATA')
283
 
    if local:
284
 
        return local
285
 
    return get_appdata_location()
 
139
    # if we fall to this point we on win98
 
140
    # at least try C:/WINDOWS/Application Data
 
141
    windir = os.environ.get('windir')
 
142
    if windir:
 
143
        appdata = os.path.join(windir, 'Application Data')
 
144
        if os.path.isdir(appdata):
 
145
            return appdata
 
146
    # did not find anything
 
147
    return None
286
148
 
287
149
 
288
150
def get_home_location():
290
152
    Assume on win32 it's the <My Documents> folder.
291
153
    If location cannot be obtained return system drive root,
292
154
    i.e. C:\
 
155
 
 
156
    Returned value can be unicode or plain sring.
 
157
    To convert plain string to unicode use
 
158
    s.decode(bzrlib.user_encoding)
293
159
    """
294
 
    home = _get_sh_special_folder_path(CSIDL_PERSONAL)
295
 
    if home:
296
 
        return home
297
 
    home = get_environ_unicode('HOME')
298
 
    if home is not None:
299
 
        return home
300
 
    homepath = get_environ_unicode('HOMEPATH')
301
 
    if homepath is not None:
302
 
        return os.path.join(get_environ_unicode('HOMEDIR', ''), home)
 
160
    if has_ctypes:
 
161
        try:
 
162
            SHGetSpecialFolderPath = \
 
163
                ctypes.windll.shell32.SHGetSpecialFolderPathW
 
164
        except AttributeError:
 
165
            pass
 
166
        else:
 
167
            buf = ctypes.create_unicode_buffer(MAX_PATH)
 
168
            if SHGetSpecialFolderPath(None,buf,CSIDL_PERSONAL,0):
 
169
                return buf.value
 
170
    # try for HOME env variable
 
171
    home = os.path.expanduser('~')
 
172
    if home != '~':
 
173
        return home
303
174
    # at least return windows root directory
304
 
    windir = get_environ_unicode('WINDIR')
 
175
    windir = os.environ.get('windir')
305
176
    if windir:
306
177
        return os.path.splitdrive(windir)[0] + '/'
307
178
    # otherwise C:\ is good enough for 98% users
308
 
    return unicode('C:/')
 
179
    return 'C:/'
309
180
 
310
181
 
311
182
def get_user_name():
312
183
    """Return user name as login name.
313
184
    If name cannot be obtained return None.
 
185
 
 
186
    Returned value can be unicode or plain sring.
 
187
    To convert plain string to unicode use
 
188
    s.decode(bzrlib.user_encoding)
314
189
    """
315
190
    if has_ctypes:
316
191
        try:
322
197
            buf = create_buffer(UNLEN+1)
323
198
            n = ctypes.c_int(UNLEN+1)
324
199
            if GetUserName(buf, ctypes.byref(n)):
325
 
                return extract_buffer(buf)
 
200
                return buf.value
326
201
    # otherwise try env variables
327
 
    return get_environ_unicode('USERNAME')
328
 
 
329
 
 
330
 
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
331
 
# computer or the cluster associated with the local computer."
332
 
_WIN32_ComputerNameDnsHostname = 1
 
202
    return os.environ.get('USERNAME', None)
 
203
 
333
204
 
334
205
def get_host_name():
335
206
    """Return host machine name.
336
207
    If name cannot be obtained return None.
337
208
 
338
 
    :return: A unicode string representing the host name.
 
209
    Returned value can be unicode or plain sring.
 
210
    To convert plain string to unicode use
 
211
    s.decode(bzrlib.user_encoding)
339
212
    """
340
 
    if has_win32api:
341
 
        try:
342
 
            return win32api.GetComputerNameEx(_WIN32_ComputerNameDnsHostname)
343
 
        except (NotImplementedError, win32api.error):
344
 
            # NotImplemented will happen on win9x...
345
 
            pass
346
213
    if has_ctypes:
347
214
        try:
348
215
            kernel32 = ctypes.windll.kernel32
 
216
            GetComputerName = getattr(kernel32, 'GetComputerName'+suffix)
349
217
        except AttributeError:
350
 
            pass # Missing the module we need
 
218
            pass
351
219
        else:
352
220
            buf = create_buffer(MAX_COMPUTERNAME_LENGTH+1)
353
221
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
354
 
 
355
 
            # Try GetComputerNameEx which gives a proper Unicode hostname
356
 
            GetComputerNameEx = getattr(kernel32, 'GetComputerNameEx'+suffix,
357
 
                                        None)
358
 
            if (GetComputerNameEx is not None
359
 
                and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
360
 
                                      buf, ctypes.byref(n))):
361
 
                return extract_buffer(buf)
362
 
 
363
 
            # Try GetComputerName in case GetComputerNameEx wasn't found
364
 
            # It returns the NETBIOS name, which isn't as good, but still ok.
365
 
            # The first GetComputerNameEx might have changed 'n', so reset it
366
 
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
367
 
            GetComputerName = getattr(kernel32, 'GetComputerName'+suffix,
368
 
                                      None)
369
 
            if (GetComputerName is not None
370
 
                and GetComputerName(buf, ctypes.byref(n))):
371
 
                return extract_buffer(buf)
372
 
    return get_environ_unicode('COMPUTERNAME')
373
 
 
374
 
 
375
 
@symbol_versioning.deprecated_function(
376
 
    symbol_versioning.deprecated_in((2, 5, 0)))
 
222
            if GetComputerName(buf, ctypes.byref(n)):
 
223
                return buf.value
 
224
    # otherwise try env variables
 
225
    return os.environ.get('COMPUTERNAME', None)
 
226
 
 
227
 
377
228
def _ensure_unicode(s):
378
229
    if s and type(s) != unicode:
379
 
        from bzrlib import osutils
380
 
        s = s.decode(osutils.get_user_encoding())
 
230
        import bzrlib
 
231
        s = s.decode(bzrlib.user_encoding)
381
232
    return s
382
 
 
383
 
 
384
 
get_appdata_location_unicode = symbol_versioning.deprecated_function(
385
 
    symbol_versioning.deprecated_in((2, 5, 0)))(get_appdata_location)
386
 
 
387
 
get_home_location_unicode = symbol_versioning.deprecated_function(
388
 
    symbol_versioning.deprecated_in((2, 5, 0)))(get_home_location)
389
 
 
390
 
get_user_name_unicode = symbol_versioning.deprecated_function(
391
 
    symbol_versioning.deprecated_in((2, 5, 0)))(get_user_name)
392
 
 
393
 
get_host_name_unicode = symbol_versioning.deprecated_function(
394
 
    symbol_versioning.deprecated_in((2, 5, 0)))(get_host_name)
 
233
    
 
234
 
 
235
def get_appdata_location_unicode():
 
236
    return _ensure_unicode(get_appdata_location())
 
237
 
 
238
def get_home_location_unicode():
 
239
    return _ensure_unicode(get_home_location())
 
240
 
 
241
def get_user_name_unicode():
 
242
    return _ensure_unicode(get_user_name())
 
243
 
 
244
def get_host_name_unicode():
 
245
    return _ensure_unicode(get_host_name())
395
246
 
396
247
 
397
248
def _ensure_with_dir(path):
398
 
    if (not os.path.split(path)[0] or path.startswith(u'*')
399
 
        or path.startswith(u'?')):
 
249
    if not os.path.split(path)[0] or path.startswith(u'*') or path.startswith(u'?'):
400
250
        return u'./' + path, True
401
251
    else:
402
252
        return path, False
403
 
 
 
253
    
404
254
def _undo_ensure_with_dir(path, corrected):
405
255
    if corrected:
406
256
        return path[2:]
408
258
        return path
409
259
 
410
260
 
411
 
def glob_one(possible_glob):
412
 
    """Same as glob.glob().
413
 
 
414
 
    work around bugs in glob.glob()
415
 
    - Python bug #1001604 ("glob doesn't return unicode with ...")
416
 
    - failing expansion for */* with non-iso-8859-* chars
417
 
    """
418
 
    corrected_glob, corrected = _ensure_with_dir(possible_glob)
419
 
    glob_files = glob.glob(corrected_glob)
420
 
 
421
 
    if not glob_files:
422
 
        # special case to let the normal code path handle
423
 
        # files that do not exist, etc.
424
 
        glob_files = [possible_glob]
425
 
    elif corrected:
426
 
        glob_files = [_undo_ensure_with_dir(elem, corrected)
427
 
                      for elem in glob_files]
428
 
    return [elem.replace(u'\\', u'/') for elem in glob_files]
429
 
 
430
261
 
431
262
def glob_expand(file_list):
432
263
    """Replacement for glob expansion by the shell.
441
272
    """
442
273
    if not file_list:
443
274
        return []
 
275
    import glob
444
276
    expanded_file_list = []
445
277
    for possible_glob in file_list:
446
 
        expanded_file_list.extend(glob_one(possible_glob))
447
 
    return expanded_file_list
 
278
        
 
279
        # work around bugs in glob.glob()
 
280
        # - Python bug #1001604 ("glob doesn't return unicode with ...")
 
281
        # - failing expansion for */* with non-iso-8859-* chars
 
282
        possible_glob, corrected = _ensure_with_dir(possible_glob)
 
283
        glob_files = glob.glob(possible_glob)
 
284
 
 
285
        if glob_files == []:
 
286
            # special case to let the normal code path handle
 
287
            # files that do not exists
 
288
            expanded_file_list.append(
 
289
                _undo_ensure_with_dir(possible_glob, corrected))
 
290
        else:
 
291
            glob_files = [_undo_ensure_with_dir(elem, corrected) for elem in glob_files]
 
292
            expanded_file_list += glob_files
 
293
            
 
294
    return [elem.replace(u'\\', u'/') for elem in expanded_file_list] 
448
295
 
449
296
 
450
297
def get_app_path(appname):
451
 
    r"""Look up in Windows registry for full path to application executable.
452
 
    Typically, applications create subkey with their basename
 
298
    """Look up in Windows registry for full path to application executable.
 
299
    Typicaly, applications create subkey with their basename
453
300
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
454
301
 
455
302
    :param  appname:    name of application (if no filename extension
458
305
                or appname itself if nothing found.
459
306
    """
460
307
    import _winreg
 
308
    try:
 
309
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
 
310
                               r'SOFTWARE\Microsoft\Windows'
 
311
                               r'\CurrentVersion\App Paths')
 
312
    except EnvironmentError:
 
313
        return appname
461
314
 
462
315
    basename = appname
463
316
    if not os.path.splitext(basename)[1]:
464
317
        basename = appname + '.exe'
465
 
 
466
 
    try:
467
 
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
468
 
            'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
469
 
            basename)
470
 
    except EnvironmentError:
471
 
        return appname
472
 
 
473
318
    try:
474
319
        try:
475
 
            path, type_id = _winreg.QueryValueEx(hkey, '')
 
320
            fullpath = _winreg.QueryValue(hkey, basename)
476
321
        except WindowsError:
477
 
            return appname
 
322
            fullpath = appname
478
323
    finally:
479
324
        _winreg.CloseKey(hkey)
480
325
 
481
 
    if type_id == REG_SZ:
482
 
        return path
483
 
    if type_id == REG_EXPAND_SZ and has_win32api:
484
 
        fullpath = win32api.ExpandEnvironmentStrings(path)
485
 
        if len(fullpath) > 1 and fullpath[0] == '"' and fullpath[-1] == '"':
486
 
            fullpath = fullpath[1:-1]   # remove quotes around value
487
 
        return fullpath
488
 
    return appname
 
326
    return fullpath
489
327
 
490
328
 
491
329
def set_file_attr_hidden(path):
492
330
    """Set file attributes to hidden if possible"""
493
331
    if has_win32file:
494
 
        if winver != 'Windows 98':
495
 
            SetFileAttributes = win32file.SetFileAttributesW
496
 
        else:
497
 
            SetFileAttributes = win32file.SetFileAttributes
498
 
        try:
499
 
            SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
500
 
        except pywintypes.error, e:
501
 
            from bzrlib import trace
502
 
            trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
503
 
 
504
 
 
505
 
def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
506
 
    """Convert a Unicode command line into a list of argv arguments.
507
 
 
508
 
    It performs wildcard expansion to make wildcards act closer to how they
509
 
    work in posix shells, versus how they work by default on Windows. Quoted
510
 
    arguments are left untouched.
511
 
 
512
 
    :param command_line: The unicode string to split into an arg list.
513
 
    :param single_quotes_allowed: Whether single quotes are accepted as quoting
514
 
                                  characters like double quotes. False by
515
 
                                  default.
516
 
    :return: A list of unicode strings.
517
 
    """
518
 
    # First, split the command line
519
 
    s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
520
 
    
521
 
    # Bug #587868 Now make sure that the length of s agrees with sys.argv 
522
 
    # we do this by simply counting the number of arguments in each. The counts should 
523
 
    # agree no matter what encoding sys.argv is in (AFAIK) 
524
 
    # len(arguments) < len(sys.argv) should be an impossibility since python gets 
525
 
    # args from the very same PEB as does GetCommandLineW
526
 
    arguments = list(s)
527
 
    
528
 
    # Now shorten the command line we get from GetCommandLineW to match sys.argv
529
 
    if len(arguments) < len(argv):
530
 
        raise AssertionError("Split command line can't be shorter than argv")
531
 
    arguments = arguments[len(arguments) - len(argv):]
532
 
    
533
 
    # Carry on to process globs (metachars) in the command line
534
 
    # expand globs if necessary
535
 
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
536
 
    #       '**/' style globs
537
 
    args = []
538
 
    for is_quoted, arg in arguments:
539
 
        if is_quoted or not glob.has_magic(arg):
540
 
            args.append(arg)
541
 
        else:
542
 
            args.extend(glob_one(arg))
543
 
    return args
544
 
 
545
 
 
546
 
if has_ctypes and winver == 'Windows NT':
547
 
    def get_unicode_argv():
548
 
        prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
549
 
        GetCommandLineW = prototype(("GetCommandLineW",
550
 
                                     ctypes.windll.kernel32))
551
 
        command_line = GetCommandLineW()
552
 
        if command_line is None:
553
 
            raise ctypes.WinError()
554
 
        # Skip the first argument, since we only care about parameters
555
 
        argv = _command_line_to_argv(command_line, sys.argv)[1:]
556
 
        return argv
557
 
    
558
 
 
559
 
    def get_environ_unicode(key, default=None):
560
 
        """Get `key` from environment as unicode or `default` if unset
561
 
 
562
 
        The environment is natively unicode on modern windows versions but
563
 
        Python 2 only accesses it through the legacy bytestring api.
564
 
 
565
 
        Environmental variable names are case insenstive on Windows.
566
 
 
567
 
        A large enough buffer will be allocated to retrieve the value, though
568
 
        it may take two calls to the underlying library function.
569
 
 
570
 
        This needs ctypes because pywin32 does not expose the wide version.
571
 
        """
572
 
        cfunc = getattr(get_environ_unicode, "_c_function", None)
573
 
        if cfunc is None:
574
 
            from ctypes.wintypes import DWORD, LPCWSTR, LPWSTR
575
 
            cfunc = ctypes.WINFUNCTYPE(DWORD, LPCWSTR, LPWSTR, DWORD)(
576
 
                ("GetEnvironmentVariableW", ctypes.windll.kernel32))
577
 
            get_environ_unicode._c_function = cfunc
578
 
        buffer_size = 256 # heuristic, 256 characters often enough
579
 
        while True:
580
 
            buffer = ctypes.create_unicode_buffer(buffer_size)
581
 
            length = cfunc(key, buffer, buffer_size)
582
 
            if not length:
583
 
                code = ctypes.GetLastError()
584
 
                if code == 203: # ERROR_ENVVAR_NOT_FOUND
585
 
                    return default
586
 
                raise ctypes.WinError(code)
587
 
            if buffer_size > length:
588
 
                return buffer[:length]
589
 
            buffer_size = length
590
 
else:
591
 
    get_unicode_argv = None
592
 
    def get_environ_unicode(key, default=None):
593
 
        """Get `key` from environment as unicode or `default` if unset
594
 
 
595
 
        Fallback version that should basically never be needed.
596
 
        """
597
 
        from bzrlib import osutils
598
 
        try:
599
 
            return os.environ[key].decode(osutils.get_user_encoding())
600
 
        except KeyError:
601
 
            return default
602
 
 
603
 
 
604
 
if has_win32api:
605
 
    def _pywin32_is_local_pid_dead(pid):
606
 
        """True if pid doesn't correspond to live process on this machine"""
607
 
        try:
608
 
            handle = win32api.OpenProcess(1, False, pid) # PROCESS_TERMINATE
609
 
        except pywintypes.error, e:
610
 
            if e[0] == 5: # ERROR_ACCESS_DENIED
611
 
                # Probably something alive we're not allowed to kill
612
 
                return False
613
 
            elif e[0] == 87: # ERROR_INVALID_PARAMETER
614
 
                return True
615
 
            raise
616
 
        handle.close()
617
 
        return False
618
 
    is_local_pid_dead = _pywin32_is_local_pid_dead
619
 
elif has_ctypes and sys.platform == 'win32':
620
 
    from ctypes.wintypes import BOOL, DWORD, HANDLE
621
 
    _kernel32 = ctypes.windll.kernel32
622
 
    _CloseHandle = ctypes.WINFUNCTYPE(BOOL, HANDLE)(
623
 
        ("CloseHandle", _kernel32))
624
 
    _OpenProcess = ctypes.WINFUNCTYPE(HANDLE, DWORD, BOOL, DWORD)(
625
 
        ("OpenProcess", _kernel32))
626
 
    def _ctypes_is_local_pid_dead(pid):
627
 
        """True if pid doesn't correspond to live process on this machine"""
628
 
        handle = _OpenProcess(1, False, pid) # PROCESS_TERMINATE
629
 
        if not handle:
630
 
            errorcode = ctypes.GetLastError()
631
 
            if errorcode == 5: # ERROR_ACCESS_DENIED
632
 
                # Probably something alive we're not allowed to kill
633
 
                return False
634
 
            elif errorcode == 87: # ERROR_INVALID_PARAMETER
635
 
                return True
636
 
            raise ctypes.WinError(errorcode)
637
 
        _CloseHandle(handle)
638
 
        return False
639
 
    is_local_pid_dead = _ctypes_is_local_pid_dead
640
 
 
641
 
 
642
 
def _is_pywintypes_error(evalue):
643
 
    """True if exception instance is an error from pywin32"""
644
 
    if has_pywintypes and isinstance(evalue, pywintypes.error):
645
 
        return True
646
 
    return False
 
332
        win32file.SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)