~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

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

• reverse the comparison (4634.146.5 to 5401)
• stop comparing with revision 5401

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

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':

135

133

                'WorkingSetSize': mem_struct.WorkingSetSize,

136

134

                'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,

137

135

                'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,

138

 

                'QuotaPeakNonPagedPoolUsage':

139

 

                    mem_struct.QuotaPeakNonPagedPoolUsage,

 

136

                'QuotaPeakNonPagedPoolUsage': mem_struct.QuotaPeakNonPagedPoolUsage,

140

137

                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,

141

138

                'PagefileUsage': mem_struct.PagefileUsage,

142

139

                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,

153

150

                   ' or win32process')

154

151

        return

155

152

    if short:

156

 

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

157

 

        trace.note('WorkingSize %7dKiB'

158

 

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

 

153

        trace.note('WorkingSize %7dKB'

 

154

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

159

155

                   info['WorkingSetSize'] / 1024,

160

156

                   info['PeakWorkingSetSize'] / 1024,

161

157

                   message)

162

158

        return

163

159

    if message:

164

160

        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)

 

161

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

 

162

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

 

163

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

 

164

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

 

165

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

171

166

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

172

167

 

173

168

 

183

178

        return (defaultx, defaulty)

184

179

 

185

180

    # To avoid problem with redirecting output via pipe

186

 

    # we need to use stderr instead of stdout

 

181

    # need to use stderr instead of stdout

187

182

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

188

183

    csbi = ctypes.create_string_buffer(22)

189

184

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

190

185

 

191

186

    if res:

192

187

        (bufx, bufy, curx, cury, wattr,

193

 

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

194

 

            "hhhhHhhhhhh", csbi.raw)

 

188

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

195

189

        sizex = right - left + 1

196

190

        sizey = bottom - top + 1

197

191

        return (sizex, sizey)

394

388

 

395

389

 

396

390

def _ensure_unicode(s):

 

391

    from bzrlib import osutils

397

392

    if s and type(s) != unicode:

398

393

        from bzrlib import osutils

399

394

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

414

409

 

415

410

 

416

411

def _ensure_with_dir(path):

417

 

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

418

 

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

 

412

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

419

413

        return u'./' + path, True

420

414

    else:

421

415

        return path, False

428

422

 

429

423

 

430

424

 

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

425

def glob_expand(file_list):

452

426

    """Replacement for glob expansion by the shell.

453

427

 

461

435

    """

462

436

    if not file_list:

463

437

        return []

 

438

    import glob

464

439

    expanded_file_list = []

465

440

    for possible_glob in file_list:

466

 

        expanded_file_list.extend(glob_one(possible_glob))

467

 

    return expanded_file_list

 

441

        # work around bugs in glob.glob()

 

442

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

 

443

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

 

444

        possible_glob, corrected = _ensure_with_dir(possible_glob)

 

445

        glob_files = glob.glob(possible_glob)

 

446

 

 

447

        if glob_files == []:

 

448

            # special case to let the normal code path handle

 

449

            # files that do not exists

 

450

            expanded_file_list.append(

 

451

                _undo_ensure_with_dir(possible_glob, corrected))

 

452

        else:

 

453

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

 

454

            expanded_file_list += glob_files

 

455

 

 

456

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

468

457

 

469

458

 

470

459

def get_app_path(appname):

522

511

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

523

512

 

524

513

 

525

 

def _command_line_to_argv(command_line, argv, 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

 

    # First, spit the command line

539

 

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

540

 

    

541

 

    # Bug #587868 Now make sure that the length of s agrees with sys.argv 

542

 

    # we do this by simply counting the number of arguments in each. The counts should 

543

 

    # agree no matter what encoding sys.argv is in (AFAIK) 

544

 

    # len(arguments) < len(sys.argv) should be an impossibility since python gets 

545

 

    # args from the very same PEB as does GetCommandLineW

546

 

    arguments = list(s)

547

 

    

548

 

    # Now shorten the command line we get from GetCommandLineW to match sys.argv

549

 

    if len(arguments) < len(argv):

550

 

        raise AssertionError("Split command line can't be shorter than argv")

551

 

    arguments = arguments[len(arguments) - len(argv):]

552

 

    

553

 

    # Carry on to process globs (metachars) in the command line

554

 

    # expand globs if necessary

555

 

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

556

 

    #       '**/' style globs

557

 

    args = []

558

 

    for is_quoted, arg in arguments:

559

 

        if is_quoted or not glob.has_magic(arg):

560

 

            args.append(arg)

561

 

        else:

562

 

            args.extend(glob_one(arg))

563

 

    return args

564

 

 

565

 

 

566

514

if has_ctypes and winver != 'Windows 98':

567

515

    def get_unicode_argv():

568

 

        prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)

569

 

        GetCommandLineW = prototype(("GetCommandLineW",

570

 

                                     ctypes.windll.kernel32))

571

 

        command_line = GetCommandLineW()

572

 

        if command_line is None:

573

 

            raise ctypes.WinError()

 

516

        LPCWSTR = ctypes.c_wchar_p

 

517

        INT = ctypes.c_int

 

518

        POINTER = ctypes.POINTER

 

519

        prototype = ctypes.WINFUNCTYPE(LPCWSTR)

 

520

        GetCommandLine = prototype(("GetCommandLineW",

 

521

                                    ctypes.windll.kernel32))

 

522

        prototype = ctypes.WINFUNCTYPE(POINTER(LPCWSTR), LPCWSTR, POINTER(INT))

 

523

        CommandLineToArgv = prototype(("CommandLineToArgvW",

 

524

                                       ctypes.windll.shell32))

 

525

        c = INT(0)

 

526

        pargv = CommandLineToArgv(GetCommandLine(), ctypes.byref(c))

574

527

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

575

 

        argv = _command_line_to_argv(command_line, sys.argv)[1:]

 

528

        argv = [pargv[i] for i in range(1, c.value)]

 

529

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

 

530

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

 

531

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

 

532

            # we need to get only BZR_OPTIONS part,

 

533

            # so let's using sys.argv[1:] as reference to get the tail

 

534

            # of unicode argv

 

535

            tail_len = len(sys.argv[1:])

 

536

            ix = len(argv) - tail_len

 

537

            argv = argv[ix:]

576

538

        return argv

577

539

else:

578

540

    get_unicode_argv = None

• Older »

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