~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

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

• reverse the comparison (5177.1.1 to 3735.40.19)
• stop comparing with revision 3735.40.19

Show diffs side-by-side

added

removed

bzrlib/win32utils.py

1

 

# Copyright (C) 2006, 2007 Canonical Ltd

 

1

# Copyright (C) 2005-2010 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

19

19

Only one dependency: ctypes should be installed.

20

20

"""

21

21

 

 

22

import glob

22

23

import os

 

24

import re

23

25

import struct

24

26

import sys

25

27

 

 

28

from bzrlib import cmdline

26

29

 

27

30

# Windows version

28

31

if sys.platform == 'win32':

66

69

        suffix = 'W'

67

70

try:

68

71

    import win32file

 

72

    import pywintypes

69

73

    has_win32file = True

70

74

except ImportError:

71

75

    has_win32file = False

96

100

UNLEN = 256

97

101

MAX_COMPUTERNAME_LENGTH = 31

98

102

 

 

103

# Registry data type ids

 

104

REG_SZ = 1

 

105

REG_EXPAND_SZ = 2

 

106

 

99

107

 

100

108

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

101

109

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

128

136

                'WorkingSetSize': mem_struct.WorkingSetSize,

129

137

                'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,

130

138

                'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,

131

 

                'QuotaPeakNonPagedPoolUsage': mem_struct.QuotaPeakNonPagedPoolUsage,

 

139

                'QuotaPeakNonPagedPoolUsage':

 

140

                    mem_struct.QuotaPeakNonPagedPoolUsage,

132

141

                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,

133

142

                'PagefileUsage': mem_struct.PagefileUsage,

134

143

                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,

145

154

                   ' or win32process')

146

155

        return

147

156

    if short:

148

 

        trace.note('WorkingSize %7dKB'

149

 

                   '\tPeakWorking %7dKB\t%s',

 

157

        # using base-2 units (see HACKING.txt).

 

158

        trace.note('WorkingSize %7dKiB'

 

159

                   '\tPeakWorking %7dKiB\t%s',

150

160

                   info['WorkingSetSize'] / 1024,

151

161

                   info['PeakWorkingSetSize'] / 1024,

152

162

                   message)

153

163

        return

154

164

    if message:

155

165

        trace.note('%s', message)

156

 

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

157

 

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

158

 

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

159

 

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

160

 

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

 

166

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

 

167

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

 

168

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

 

169

    trace.note('PeakPagefileUsage %8d KiB',

 

170

               info.get('PeakPagefileUsage', 0) / 1024)

 

171

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

161

172

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

162

173

 

163

174

 

173

184

        return (defaultx, defaulty)

174

185

 

175

186

    # To avoid problem with redirecting output via pipe

176

 

    # need to use stderr instead of stdout

 

187

    # we need to use stderr instead of stdout

177

188

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

178

189

    csbi = ctypes.create_string_buffer(22)

179

190

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

180

191

 

181

192

    if res:

182

193

        (bufx, bufy, curx, cury, wattr,

183

 

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

 

194

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

 

195

            "hhhhHhhhhhh", csbi.raw)

184

196

        sizex = right - left + 1

185

197

        sizey = bottom - top + 1

186

198

        return (sizex, sizey)

267

279

 

268

280

    Returned value can be unicode or plain string.

269

281

    To convert plain string to unicode use

270

 

    s.decode(bzrlib.user_encoding)

 

282

    s.decode(osutils.get_user_encoding())

271

283

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

272

284

    """

273

285

    local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)

286

298

    If location cannot be obtained return system drive root,

287

299

    i.e. C:\

288

300

 

289

 

    Returned value can be unicode or plain sring.

 

301

    Returned value can be unicode or plain string.

290

302

    To convert plain string to unicode use

291

303

    s.decode(osutils.get_user_encoding())

292

304

    """

309

321

    """Return user name as login name.

310

322

    If name cannot be obtained return None.

311

323

 

312

 

    Returned value can be unicode or plain sring.

 

324

    Returned value can be unicode or plain string.

313

325

    To convert plain string to unicode use

314

326

    s.decode(osutils.get_user_encoding())

315

327

    """

383

395

 

384

396

 

385

397

def _ensure_unicode(s):

386

 

    from bzrlib import osutils

387

398

    if s and type(s) != unicode:

388

399

        from bzrlib import osutils

389

400

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

404

415

 

405

416

 

406

417

def _ensure_with_dir(path):

407

 

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

 

418

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

 

419

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

408

420

        return u'./' + path, True

409

421

    else:

410

422

        return path, False

417

429

 

418

430

 

419

431

 

 

432

def glob_one(possible_glob):

 

433

    """Same as glob.glob().

 

434

 

 

435

    work around bugs in glob.glob()

 

436

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

 

437

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

 

438

    """

 

439

    corrected_glob, corrected = _ensure_with_dir(possible_glob)

 

440

    glob_files = glob.glob(corrected_glob)

 

441

 

 

442

    if not glob_files:

 

443

        # special case to let the normal code path handle

 

444

        # files that do not exist, etc.

 

445

        glob_files = [possible_glob]

 

446

    elif corrected:

 

447

        glob_files = [_undo_ensure_with_dir(elem, corrected)

 

448

                      for elem in glob_files]

 

449

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

 

450

 

 

451

 

420

452

def glob_expand(file_list):

421

453

    """Replacement for glob expansion by the shell.

422

454

 

430

462

    """

431

463

    if not file_list:

432

464

        return []

433

 

    import glob

434

465

    expanded_file_list = []

435

466

    for possible_glob in file_list:

436

 

 

437

 

        # work around bugs in glob.glob()

438

 

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

439

 

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

440

 

        possible_glob, corrected = _ensure_with_dir(possible_glob)

441

 

        glob_files = glob.glob(possible_glob)

442

 

 

443

 

        if glob_files == []:

444

 

            # special case to let the normal code path handle

445

 

            # files that do not exists

446

 

            expanded_file_list.append(

447

 

                _undo_ensure_with_dir(possible_glob, corrected))

448

 

        else:

449

 

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

450

 

            expanded_file_list += glob_files

451

 

 

452

 

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

 

467

        expanded_file_list.extend(glob_one(possible_glob))

 

468

    return expanded_file_list

453

469

 

454

470

 

455

471

def get_app_path(appname):

456

472

    """Look up in Windows registry for full path to application executable.

457

 

    Typicaly, applications create subkey with their basename

 

473

    Typically, applications create subkey with their basename

458

474

    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\

459

475

 

460

476

    :param  appname:    name of application (if no filename extension

463

479

                or appname itself if nothing found.

464

480

    """

465

481

    import _winreg

 

482

 

 

483

    basename = appname

 

484

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

 

485

        basename = appname + '.exe'

 

486

 

466

487

    try:

467

488

        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,

468

 

                               r'SOFTWARE\Microsoft\Windows'

469

 

                               r'\CurrentVersion\App Paths')

 

489

            'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +

 

490

            basename)

470

491

    except EnvironmentError:

471

492

        return appname

472

493

 

473

 

    basename = appname

474

 

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

475

 

        basename = appname + '.exe'

476

494

    try:

477

495

        try:

478

 

            fullpath = _winreg.QueryValue(hkey, basename)

 

496

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

479

497

        except WindowsError:

480

 

            fullpath = appname

 

498

            return appname

481

499

    finally:

482

500

        _winreg.CloseKey(hkey)

483

501

 

484

 

    return fullpath

 

502

    if type_id == REG_SZ:

 

503

        return path

 

504

    if type_id == REG_EXPAND_SZ and has_win32api:

 

505

        fullpath = win32api.ExpandEnvironmentStrings(path)

 

506

        if len(fullpath) > 1 and fullpath[0] == '"' and fullpath[-1] == '"':

 

507

            fullpath = fullpath[1:-1]   # remove quotes around value

 

508

        return fullpath

 

509

    return appname

485

510

 

486

511

 

487

512

def set_file_attr_hidden(path):

488

513

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

489

514

    if has_win32file:

490

 

        win32file.SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)

 

515

        if winver != 'Windows 98':

 

516

            SetFileAttributes = win32file.SetFileAttributesW

 

517

        else:

 

518

            SetFileAttributes = win32file.SetFileAttributes

 

519

        try:

 

520

            SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)

 

521

        except pywintypes.error, e:

 

522

            from bzrlib import trace

 

523

            trace.mutter('Unable to set hidden attribute on %r: %s', path, e)

 

524

 

 

525

 

 

526

def _command_line_to_argv(command_line, single_quotes_allowed=False):

 

527

    """Convert a Unicode command line into a list of argv arguments.

 

528

 

 

529

    It performs wildcard expansion to make wildcards act closer to how they

 

530

    work in posix shells, versus how they work by default on Windows. Quoted

 

531

    arguments are left untouched.

 

532

 

 

533

    :param command_line: The unicode string to split into an arg list.

 

534

    :param single_quotes_allowed: Whether single quotes are accepted as quoting

 

535

                                  characters like double quotes. False by

 

536

                                  default.

 

537

    :return: A list of unicode strings.

 

538

    """

 

539

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

 

540

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

 

541

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

 

542

    #       '**/' style globs

 

543

    args = []

 

544

    for is_quoted, arg in s:

 

545

        if is_quoted or not glob.has_magic(arg):

 

546

            args.append(arg)

 

547

        else:

 

548

            args.extend(glob_one(arg))

 

549

    return args

 

550

 

 

551

 

 

552

if has_ctypes and winver != 'Windows 98':

 

553

    def get_unicode_argv():

 

554

        prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)

 

555

        GetCommandLineW = prototype(("GetCommandLineW",

 

556

                                     ctypes.windll.kernel32))

 

557

        command_line = GetCommandLineW()

 

558

        if command_line is None:

 

559

            raise ctypes.WinError()

 

560

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

 

561

        argv = _command_line_to_argv(command_line)[1:]

 

562

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

 

563

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

 

564

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

 

565

            # we need to get only BZR_OPTIONS part,

 

566

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

 

567

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

 

568

            for idx in xrange(len(argv)):

 

569

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

 

570

                    break

 

571

            argv = argv[idx+1:]

 

572

        return argv

 

573

else:

 

574

    get_unicode_argv = None

• Older »

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