DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Mercurial (409f3966645a)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.

# This is a partial python port of nsinstall.
# It's intended to be used when there's no natively compile nsinstall
# available, and doesn't intend to be fully equivalent.
# Its major use is for l10n repackaging on systems that don't have
# a full build environment set up.
# The basic limitation is, it doesn't even try to link and ignores
# all related options.
from __future__ import print_function
from optparse import OptionParser
import mozfile
import os
import os.path
import sys
import shutil


def _nsinstall_internal(argv):
    usage = "usage: %prog [options] arg1 [arg2 ...] target-directory"
    p = OptionParser(usage=usage)

    p.add_option('-D', action="store_true",
                 help="Create a single directory only")
    p.add_option('-t', action="store_true",
                 help="Preserve time stamp")
    p.add_option('-m', action="store",
                 help="Set mode", metavar="mode")
    p.add_option('-d', action="store_true",
                 help="Create directories in target")
    p.add_option('-R', action="store_true",
                 help="Use relative symbolic links (ignored)")
    p.add_option('-L', action="store", metavar="linkprefix",
                 help="Link prefix (ignored)")
    p.add_option('-X', action="append", metavar="file",
                 help="Ignore a file when installing a directory recursively.")

    # The remaining arguments are not used in our tree, thus they're not
    # implented.
    def BadArg(option, opt, value, parser):
        parser.error('option not supported: {0}'.format(opt))

    p.add_option('-C', action="callback", metavar="CWD",
                 callback=BadArg,
                 help="NOT SUPPORTED")
    p.add_option('-o', action="callback", callback=BadArg,
                 help="Set owner (NOT SUPPORTED)", metavar="owner")
    p.add_option('-g', action="callback", callback=BadArg,
                 help="Set group (NOT SUPPORTED)", metavar="group")

    (options, args) = p.parse_args(argv)

    if options.m:
        # mode is specified
        try:
            options.m = int(options.m, 8)
        except Exception:
            sys.stderr.write('nsinstall: {0} is not a valid mode\n'
                             .format(options.m))
            return 1

    # just create one directory?
    def maybe_create_dir(dir, mode, try_again):
        dir = os.path.abspath(dir)
        if os.path.exists(dir):
            if not os.path.isdir(dir):
                print('nsinstall: {0} is not a directory'.format(dir), file=sys.stderr)
                return 1
            if mode:
                os.chmod(dir, mode)
            return 0

        try:
            if mode:
                os.makedirs(dir, mode)
            else:
                os.makedirs(dir)
        except Exception as e:
            # We might have hit EEXIST due to a race condition (see bug 463411) -- try again once
            if try_again:
                return maybe_create_dir(dir, mode, False)
            print(
                "nsinstall: failed to create directory {0}: {1}".format(dir, e))
            return 1
        else:
            return 0

    if options.X:
        options.X = [os.path.abspath(path) for path in options.X]

    if options.D:
        return maybe_create_dir(args[0], options.m, True)

    # nsinstall arg1 [...] directory
    if len(args) < 2:
        p.error('not enough arguments')

    def copy_all_entries(entries, target):
        for e in entries:
            e = os.path.abspath(e)
            if options.X and e in options.X:
                continue

            dest = os.path.join(target, os.path.basename(e))
            dest = os.path.abspath(dest)
            handleTarget(e, dest)
            if options.m:
                os.chmod(dest, options.m)

    # set up handler
    if options.d:
        # we're supposed to create directories
        def handleTarget(srcpath, targetpath):
            # target directory was already created, just use mkdir
            os.mkdir(targetpath)
    else:
        # we're supposed to copy files
        def handleTarget(srcpath, targetpath):
            if os.path.isdir(srcpath):
                if not os.path.exists(targetpath):
                    os.mkdir(targetpath)
                entries = [os.path.join(srcpath, e)
                           for e in os.listdir(srcpath)]
                copy_all_entries(entries, targetpath)
                # options.t is not relevant for directories
                if options.m:
                    os.chmod(targetpath, options.m)
            else:
                if os.path.exists(targetpath):
                    if sys.platform == "win32":
                        mozfile.remove(targetpath)
                    else:
                        os.remove(targetpath)
                if options.t:
                    shutil.copy2(srcpath, targetpath)
                else:
                    shutil.copy(srcpath, targetpath)

    # the last argument is the target directory
    target = args.pop()
    # ensure target directory (importantly, we do not apply a mode to the directory
    # because we want to copy files into it and the mode might be read-only)
    rv = maybe_create_dir(target, None, True)
    if rv != 0:
        return rv

    copy_all_entries(args, target)
    return 0

# nsinstall as a native command is always UTF-8


def nsinstall(argv):
    return _nsinstall_internal([unicode(arg, "utf-8") for arg in argv])


if __name__ == '__main__':
    # sys.argv corrupts characters outside the system code page on Windows
    # <http://bugs.python.org/issue2128>. Use ctypes instead. This is also
    # useful because switching to Unicode strings makes python use the wide
    # Windows APIs, which is what we want here since the wide APIs normally do a
    # better job at handling long paths and such.
    if sys.platform == "win32":
        import ctypes
        from ctypes import wintypes
        GetCommandLine = ctypes.windll.kernel32.GetCommandLineW
        GetCommandLine.argtypes = []
        GetCommandLine.restype = wintypes.LPWSTR

        CommandLineToArgv = ctypes.windll.shell32.CommandLineToArgvW
        CommandLineToArgv.argtypes = [
            wintypes.LPWSTR, ctypes.POINTER(ctypes.c_int)]
        CommandLineToArgv.restype = ctypes.POINTER(wintypes.LPWSTR)

        argc = ctypes.c_int(0)
        argv_arr = CommandLineToArgv(GetCommandLine(), ctypes.byref(argc))
        # The first argv will be "python", the second will be the .py file
        argv = argv_arr[1:argc.value]
    else:
        # For consistency, do it on Unix as well
        if sys.stdin.encoding is not None:
            argv = [unicode(arg, sys.stdin.encoding) for arg in sys.argv]
        else:
            argv = [unicode(arg) for arg in sys.argv]

    sys.exit(_nsinstall_internal(argv[1:]))