~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

• browse files at revision 4031.3.1
• compare with another revision
• download diff
• download tarball
• view history from revision 4031.3.1

• reverse the comparison (4031.3.1 to 5200.3.1)
• stop comparing with revision 5200.3.1

Show diffs side-by-side

added

removed

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

 

import glob

23

22

import os

24

23

import struct

25

24

import sys

26

25

 

27

 

from bzrlib import cmdline

28

26

 

29

27

# Windows version

30

28

if sys.platform == 'win32':

68

66

        suffix = 'W'

69

67

try:

70

68

    import win32file

71

 

    import pywintypes

72

69

    has_win32file = True

73

70

except ImportError:

74

71

    has_win32file = False

99

96

UNLEN = 256

100

97

MAX_COMPUTERNAME_LENGTH = 31

101

98

 

102

 

# Registry data type ids

103

 

REG_SZ = 1

104

 

REG_EXPAND_SZ = 2

105

 

 

106

99

 

107

100

def debug_memory_win32api(message='', short=True):

108

101

    """Use trace.note() to dump the running memory info."""

135

128

                'WorkingSetSize': mem_struct.WorkingSetSize,

136

129

                'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,

137

130

                'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,

138

 

                'QuotaPeakNonPagedPoolUsage':

139

 

                    mem_struct.QuotaPeakNonPagedPoolUsage,

 

131

                'QuotaPeakNonPagedPoolUsage': mem_struct.QuotaPeakNonPagedPoolUsage,

140

132

                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,

141

133

                'PagefileUsage': mem_struct.PagefileUsage,

142

134

                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,

152

144

        trace.note('Cannot debug memory on win32 without ctypes'

153

145

                   ' or win32process')

154

146

        return

 

147

    trace.note('WorkingSize       %8d kB', info['WorkingSetSize'] / 1024)

 

148

    trace.note('PeakWorking       %8d kB', info['PeakWorkingSetSize'] / 1024)

155

149

    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

150

        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)

 

151

    trace.note('PagefileUsage     %8d kB', info.get('PagefileUsage', 0) / 1024)

 

152

    trace.note('PeakPagefileUsage %8d kB', info.get('PeakPagefileUsage', 0) / 1024)

 

153

    trace.note('PrivateUsage      %8d kB', info.get('PrivateUsage', 0) / 1024)

171

154

    trace.note('PageFaultCount    %8d', info.get('PageFaultCount', 0))

172

155

 

173

156

 

183

166

        return (defaultx, defaulty)

184

167

 

185

168

    # To avoid problem with redirecting output via pipe

186

 

    # we need to use stderr instead of stdout

 

169

    # need to use stderr instead of stdout

187

170

    h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)

188

171

    csbi = ctypes.create_string_buffer(22)

189

172

    res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)

190

173

 

191

174

    if res:

192

175

        (bufx, bufy, curx, cury, wattr,

193

 

        left, top, right, bottom, maxx, maxy) = struct.unpack(

194

 

            "hhhhHhhhhhh", csbi.raw)

 

176

        left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)

195

177

        sizex = right - left + 1

196

178

        sizey = bottom - top + 1

197

179

        return (sizex, sizey)

201

183

 

202

184

def _get_sh_special_folder_path(csidl):

203

185

    """Call SHGetSpecialFolderPathW if available, or return None.

204

 

 

 

186

    

205

187

    Result is always unicode (or None).

206

188

    """

207

189

    if has_ctypes:

278

260

 

279

261

    Returned value can be unicode or plain string.

280

262

    To convert plain string to unicode use

281

 

    s.decode(osutils.get_user_encoding())

 

263

    s.decode(bzrlib.user_encoding)

282

264

    (XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')

283

265

    """

284

266

    local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)

394

376

 

395

377

 

396

378

def _ensure_unicode(s):

 

379

    from bzrlib import osutils

397

380

    if s and type(s) != unicode:

398

381

        from bzrlib import osutils

399

382

        s = s.decode(osutils.get_user_encoding())

414

397

 

415

398

 

416

399

def _ensure_with_dir(path):

417

 

    if (not os.path.split(path)[0] or path.startswith(u'*')

418

 

        or path.startswith(u'?')):

 

400

    if not os.path.split(path)[0] or path.startswith(u'*') or path.startswith(u'?'):

419

401

        return u'./' + path, True

420

402

    else:

421

403

        return path, False

422

 

 

 

404

    

423

405

def _undo_ensure_with_dir(path, corrected):

424

406

    if corrected:

425

407

        return path[2:]

428

410

 

429

411

 

430

412

 

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

413

def glob_expand(file_list):

452

414

    """Replacement for glob expansion by the shell.

453

415

 

461

423

    """

462

424

    if not file_list:

463

425

        return []

 

426

    import glob

464

427

    expanded_file_list = []

465

428

    for possible_glob in file_list:

466

 

        expanded_file_list.extend(glob_one(possible_glob))

467

 

    return expanded_file_list

 

429

        

 

430

        # work around bugs in glob.glob()

 

431

        # - Python bug #1001604 ("glob doesn't return unicode with ...")

 

432

        # - failing expansion for */* with non-iso-8859-* chars

 

433

        possible_glob, corrected = _ensure_with_dir(possible_glob)

 

434

        glob_files = glob.glob(possible_glob)

 

435

 

 

436

        if glob_files == []:

 

437

            # special case to let the normal code path handle

 

438

            # files that do not exists

 

439

            expanded_file_list.append(

 

440

                _undo_ensure_with_dir(possible_glob, corrected))

 

441

        else:

 

442

            glob_files = [_undo_ensure_with_dir(elem, corrected) for elem in glob_files]

 

443

            expanded_file_list += glob_files

 

444

            

 

445

    return [elem.replace(u'\\', u'/') for elem in expanded_file_list] 

468

446

 

469

447

 

470

448

def get_app_path(appname):

478

456

                or appname itself if nothing found.

479

457

    """

480

458

    import _winreg

 

459

    try:

 

460

        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,

 

461

                               r'SOFTWARE\Microsoft\Windows'

 

462

                               r'\CurrentVersion\App Paths')

 

463

    except EnvironmentError:

 

464

        return appname

481

465

 

482

466

    basename = appname

483

467

    if not os.path.splitext(basename)[1]:

484

468

        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

469

    try:

494

470

        try:

495

 

            path, type_id = _winreg.QueryValueEx(hkey, '')

 

471

            fullpath = _winreg.QueryValue(hkey, basename)

496

472

        except WindowsError:

497

 

            return appname

 

473

            fullpath = appname

498

474

    finally:

499

475

        _winreg.CloseKey(hkey)

500

476

 

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

 

477

    return fullpath

509

478

 

510

479

 

511

480

def set_file_attr_hidden(path):

512

481

    """Set file attributes to hidden if possible"""

513

482

    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, 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

 

    s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)

539

 

    # Now that we've split the content, expand globs if necessary

540

 

    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like

541

 

    #       '**/' style globs

542

 

    args = []

543

 

    for is_quoted, arg in s:

544

 

        if is_quoted or not glob.has_magic(arg):

545

 

            args.append(arg)

546

 

        else:

547

 

            args.extend(glob_one(arg))

548

 

    return args

549

 

 

550

 

 

551

 

if has_ctypes and winver != 'Windows 98':

552

 

    def get_unicode_argv():

553

 

        prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)

554

 

        GetCommandLineW = prototype(("GetCommandLineW",

555

 

                                     ctypes.windll.kernel32))

556

 

        command_line = GetCommandLineW()

557

 

        if command_line is None:

558

 

            raise ctypes.WinError()

559

 

        # Skip the first argument, since we only care about parameters

560

 

        argv = _command_line_to_argv(command_line)[1:]

561

 

        if getattr(sys, 'frozen', None) is None:

562

 

            # Invoked via 'python.exe' which takes the form:

563

 

            #   python.exe [PYTHON_OPTIONS] C:\Path\bzr [BZR_OPTIONS]

564

 

            # we need to get only BZR_OPTIONS part,

565

 

            # We already removed 'python.exe' so we remove everything up to and

566

 

            # including the first non-option ('-') argument.

567

 

            for idx in xrange(len(argv)):

568

 

                if argv[idx][:1] != '-':

569

 

                    break

570

 

            argv = argv[idx+1:]

571

 

        return argv

572

 

else:

573

 

    get_unicode_argv = None

 

483

        win32file.SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1