python, hg: tow outside the environment.

they've served us well, and can ride off into the sunset.

1 files changed, 0 insertions, 595 deletions

diff --git a/sys/lib/python/modulefinder.py b/sys/lib/python/modulefinder.py
deleted file mode 100644
index 25e14827c..000000000
--- a/sys/lib/python/modulefinder.py
+++ /dev/null
@@ -1,595 +0,0 @@
-"""Find modules used by a script, using introspection."""
-
-# This module should be kept compatible with Python 2.2, see PEP 291.
-
-import dis
-import imp
-import marshal
-import os
-import sys
-import new
-
-if hasattr(sys.__stdout__, "newlines"):
-    READ_MODE = "U"  # universal line endings
-else:
-    # remain compatible with Python  < 2.3
-    READ_MODE = "r"
-
-LOAD_CONST = dis.opname.index('LOAD_CONST')
-IMPORT_NAME = dis.opname.index('IMPORT_NAME')
-STORE_NAME = dis.opname.index('STORE_NAME')
-STORE_GLOBAL = dis.opname.index('STORE_GLOBAL')
-STORE_OPS = [STORE_NAME, STORE_GLOBAL]
-
-# Modulefinder does a good job at simulating Python's, but it can not
-# handle __path__ modifications packages make at runtime.  Therefore there
-# is a mechanism whereby you can register extra paths in this map for a
-# package, and it will be honored.
-
-# Note this is a mapping is lists of paths.
-packagePathMap = {}
-
-# A Public interface
-def AddPackagePath(packagename, path):
-    paths = packagePathMap.get(packagename, [])
-    paths.append(path)
-    packagePathMap[packagename] = paths
-
-replacePackageMap = {}
-
-# This ReplacePackage mechanism allows modulefinder to work around the
-# way the _xmlplus package injects itself under the name "xml" into
-# sys.modules at runtime by calling ReplacePackage("_xmlplus", "xml")
-# before running ModuleFinder.
-
-def ReplacePackage(oldname, newname):
-    replacePackageMap[oldname] = newname
-
-
-class Module:
-
-    def __init__(self, name, file=None, path=None):
-        self.__name__ = name
-        self.__file__ = file
-        self.__path__ = path
-        self.__code__ = None
-        # The set of global names that are assigned to in the module.
-        # This includes those names imported through starimports of
-        # Python modules.
-        self.globalnames = {}
-        # The set of starimports this module did that could not be
-        # resolved, ie. a starimport from a non-Python module.
-        self.starimports = {}
-
-    def __repr__(self):
-        s = "Module(%r" % (self.__name__,)
-        if self.__file__ is not None:
-            s = s + ", %r" % (self.__file__,)
-        if self.__path__ is not None:
-            s = s + ", %r" % (self.__path__,)
-        s = s + ")"
-        return s
-
-class ModuleFinder:
-
-    def __init__(self, path=None, debug=0, excludes=[], replace_paths=[]):
-        if path is None:
-            path = sys.path
-        self.path = path
-        self.modules = {}
-        self.badmodules = {}
-        self.debug = debug
-        self.indent = 0
-        self.excludes = excludes
-        self.replace_paths = replace_paths
-        self.processed_paths = []   # Used in debugging only
-
-    def msg(self, level, str, *args):
-        if level <= self.debug:
-            for i in range(self.indent):
-                print "   ",
-            print str,
-            for arg in args:
-                print repr(arg),
-            print
-
-    def msgin(self, *args):
-        level = args[0]
-        if level <= self.debug:
-            self.indent = self.indent + 1
-            self.msg(*args)
-
-    def msgout(self, *args):
-        level = args[0]
-        if level <= self.debug:
-            self.indent = self.indent - 1
-            self.msg(*args)
-
-    def run_script(self, pathname):
-        self.msg(2, "run_script", pathname)
-        fp = open(pathname, READ_MODE)
-        stuff = ("", "r", imp.PY_SOURCE)
-        self.load_module('__main__', fp, pathname, stuff)
-
-    def load_file(self, pathname):
-        dir, name = os.path.split(pathname)
-        name, ext = os.path.splitext(name)
-        fp = open(pathname, READ_MODE)
-        stuff = (ext, "r", imp.PY_SOURCE)
-        self.load_module(name, fp, pathname, stuff)
-
-    def import_hook(self, name, caller=None, fromlist=None):
-        self.msg(3, "import_hook", name, caller, fromlist)
-        parent = self.determine_parent(caller)
-        q, tail = self.find_head_package(parent, name)
-        m = self.load_tail(q, tail)
-        if not fromlist:
-            return q
-        if m.__path__:
-            self.ensure_fromlist(m, fromlist)
-        return None
-
-    def determine_parent(self, caller):
-        self.msgin(4, "determine_parent", caller)
-        if not caller:
-            self.msgout(4, "determine_parent -> None")
-            return None
-        pname = caller.__name__
-        if caller.__path__:
-            parent = self.modules[pname]
-            assert caller is parent
-            self.msgout(4, "determine_parent ->", parent)
-            return parent
-        if '.' in pname:
-            i = pname.rfind('.')
-            pname = pname[:i]
-            parent = self.modules[pname]
-            assert parent.__name__ == pname
-            self.msgout(4, "determine_parent ->", parent)
-            return parent
-        self.msgout(4, "determine_parent -> None")
-        return None
-
-    def find_head_package(self, parent, name):
-        self.msgin(4, "find_head_package", parent, name)
-        if '.' in name:
-            i = name.find('.')
-            head = name[:i]
-            tail = name[i+1:]
-        else:
-            head = name
-            tail = ""
-        if parent:
-            qname = "%s.%s" % (parent.__name__, head)
-        else:
-            qname = head
-        q = self.import_module(head, qname, parent)
-        if q:
-            self.msgout(4, "find_head_package ->", (q, tail))
-            return q, tail
-        if parent:
-            qname = head
-            parent = None
-            q = self.import_module(head, qname, parent)
-            if q:
-                self.msgout(4, "find_head_package ->", (q, tail))
-                return q, tail
-        self.msgout(4, "raise ImportError: No module named", qname)
-        raise ImportError, "No module named " + qname
-
-    def load_tail(self, q, tail):
-        self.msgin(4, "load_tail", q, tail)
-        m = q
-        while tail:
-            i = tail.find('.')
-            if i < 0: i = len(tail)
-            head, tail = tail[:i], tail[i+1:]
-            mname = "%s.%s" % (m.__name__, head)
-            m = self.import_module(head, mname, m)
-            if not m:
-                self.msgout(4, "raise ImportError: No module named", mname)
-                raise ImportError, "No module named " + mname
-        self.msgout(4, "load_tail ->", m)
-        return m
-
-    def ensure_fromlist(self, m, fromlist, recursive=0):
-        self.msg(4, "ensure_fromlist", m, fromlist, recursive)
-        for sub in fromlist:
-            if sub == "*":
-                if not recursive:
-                    all = self.find_all_submodules(m)
-                    if all:
-                        self.ensure_fromlist(m, all, 1)
-            elif not hasattr(m, sub):
-                subname = "%s.%s" % (m.__name__, sub)
-                submod = self.import_module(sub, subname, m)
-                if not submod:
-                    raise ImportError, "No module named " + subname
-
-    def find_all_submodules(self, m):
-        if not m.__path__:
-            return
-        modules = {}
-        # 'suffixes' used to be a list hardcoded to [".py", ".pyc", ".pyo"].
-        # But we must also collect Python extension modules - although
-        # we cannot separate normal dlls from Python extensions.
-        suffixes = []
-        for triple in imp.get_suffixes():
-            suffixes.append(triple[0])
-        for dir in m.__path__:
-            try:
-                names = os.listdir(dir)
-            except os.error:
-                self.msg(2, "can't list directory", dir)
-                continue
-            for name in names:
-                mod = None
-                for suff in suffixes:
-                    n = len(suff)
-                    if name[-n:] == suff:
-                        mod = name[:-n]
-                        break
-                if mod and mod != "__init__":
-                    modules[mod] = mod
-        return modules.keys()
-
-    def import_module(self, partname, fqname, parent):
-        self.msgin(3, "import_module", partname, fqname, parent)
-        try:
-            m = self.modules[fqname]
-        except KeyError:
-            pass
-        else:
-            self.msgout(3, "import_module ->", m)
-            return m
-        if self.badmodules.has_key(fqname):
-            self.msgout(3, "import_module -> None")
-            return None
-        if parent and parent.__path__ is None:
-            self.msgout(3, "import_module -> None")
-            return None
-        try:
-            fp, pathname, stuff = self.find_module(partname,
-                                                   parent and parent.__path__, parent)
-        except ImportError:
-            self.msgout(3, "import_module ->", None)
-            return None
-        try:
-            m = self.load_module(fqname, fp, pathname, stuff)
-        finally:
-            if fp: fp.close()
-        if parent:
-            setattr(parent, partname, m)
-        self.msgout(3, "import_module ->", m)
-        return m
-
-    def load_module(self, fqname, fp, pathname, (suffix, mode, type)):
-        self.msgin(2, "load_module", fqname, fp and "fp", pathname)
-        if type == imp.PKG_DIRECTORY:
-            m = self.load_package(fqname, pathname)
-            self.msgout(2, "load_module ->", m)
-            return m
-        if type == imp.PY_SOURCE:
-            co = compile(fp.read()+'\n', pathname, 'exec')
-        elif type == imp.PY_COMPILED:
-            if fp.read(4) != imp.get_magic():
-                self.msgout(2, "raise ImportError: Bad magic number", pathname)
-                raise ImportError, "Bad magic number in %s" % pathname
-            fp.read(4)
-            co = marshal.load(fp)
-        else:
-            co = None
-        m = self.add_module(fqname)
-        m.__file__ = pathname
-        if co:
-            if self.replace_paths:
-                co = self.replace_paths_in_code(co)
-            m.__code__ = co
-            self.scan_code(co, m)
-        self.msgout(2, "load_module ->", m)
-        return m
-
-    def _add_badmodule(self, name, caller):
-        if name not in self.badmodules:
-            self.badmodules[name] = {}
-        self.badmodules[name][caller.__name__] = 1
-
-    def _safe_import_hook(self, name, caller, fromlist):
-        # wrapper for self.import_hook() that won't raise ImportError
-        if name in self.badmodules:
-            self._add_badmodule(name, caller)
-            return
-        try:
-            self.import_hook(name, caller)
-        except ImportError, msg:
-            self.msg(2, "ImportError:", str(msg))
-            self._add_badmodule(name, caller)
-        else:
-            if fromlist:
-                for sub in fromlist:
-                    if sub in self.badmodules:
-                        self._add_badmodule(sub, caller)
-                        continue
-                    try:
-                        self.import_hook(name, caller, [sub])
-                    except ImportError, msg:
-                        self.msg(2, "ImportError:", str(msg))
-                        fullname = name + "." + sub
-                        self._add_badmodule(fullname, caller)
-
-    def scan_code(self, co, m):
-        code = co.co_code
-        n = len(code)
-        i = 0
-        fromlist = None
-        while i < n:
-            c = code[i]
-            i = i+1
-            op = ord(c)
-            if op >= dis.HAVE_ARGUMENT:
-                oparg = ord(code[i]) + ord(code[i+1])*256
-                i = i+2
-            if op == LOAD_CONST:
-                # An IMPORT_NAME is always preceded by a LOAD_CONST, it's
-                # a tuple of "from" names, or None for a regular import.
-                # The tuple may contain "*" for "from <mod> import *"
-                fromlist = co.co_consts[oparg]
-            elif op == IMPORT_NAME:
-                assert fromlist is None or type(fromlist) is tuple
-                name = co.co_names[oparg]
-                have_star = 0
-                if fromlist is not None:
-                    if "*" in fromlist:
-                        have_star = 1
-                    fromlist = [f for f in fromlist if f != "*"]
-                self._safe_import_hook(name, m, fromlist)
-                if have_star:
-                    # We've encountered an "import *". If it is a Python module,
-                    # the code has already been parsed and we can suck out the
-                    # global names.
-                    mm = None
-                    if m.__path__:
-                        # At this point we don't know whether 'name' is a
-                        # submodule of 'm' or a global module. Let's just try
-                        # the full name first.
-                        mm = self.modules.get(m.__name__ + "." + name)
-                    if mm is None:
-                        mm = self.modules.get(name)
-                    if mm is not None:
-                        m.globalnames.update(mm.globalnames)
-                        m.starimports.update(mm.starimports)
-                        if mm.__code__ is None:
-                            m.starimports[name] = 1
-                    else:
-                        m.starimports[name] = 1
-            elif op in STORE_OPS:
-                # keep track of all global names that are assigned to
-                name = co.co_names[oparg]
-                m.globalnames[name] = 1
-        for c in co.co_consts:
-            if isinstance(c, type(co)):
-                self.scan_code(c, m)
-
-    def load_package(self, fqname, pathname):
-        self.msgin(2, "load_package", fqname, pathname)
-        newname = replacePackageMap.get(fqname)
-        if newname:
-            fqname = newname
-        m = self.add_module(fqname)
-        m.__file__ = pathname
-        m.__path__ = [pathname]
-
-        # As per comment at top of file, simulate runtime __path__ additions.
-        m.__path__ = m.__path__ + packagePathMap.get(fqname, [])
-
-        fp, buf, stuff = self.find_module("__init__", m.__path__)
-        self.load_module(fqname, fp, buf, stuff)
-        self.msgout(2, "load_package ->", m)
-        return m
-
-    def add_module(self, fqname):
-        if self.modules.has_key(fqname):
-            return self.modules[fqname]
-        self.modules[fqname] = m = Module(fqname)
-        return m
-
-    def find_module(self, name, path, parent=None):
-        if parent is not None:
-            # assert path is not None
-            fullname = parent.__name__+'.'+name
-        else:
-            fullname = name
-        if fullname in self.excludes:
-            self.msgout(3, "find_module -> Excluded", fullname)
-            raise ImportError, name
-
-        if path is None:
-            if name in sys.builtin_module_names:
-                return (None, None, ("", "", imp.C_BUILTIN))
-
-            path = self.path
-        return imp.find_module(name, path)
-
-    def report(self):
-        """Print a report to stdout, listing the found modules with their
-        paths, as well as modules that are missing, or seem to be missing.
-        """
-        print
-        print "  %-25s %s" % ("Name", "File")
-        print "  %-25s %s" % ("----", "----")
-        # Print modules found
-        keys = self.modules.keys()
-        keys.sort()
-        for key in keys:
-            m = self.modules[key]
-            if m.__path__:
-                print "P",
-            else:
-                print "m",
-            print "%-25s" % key, m.__file__ or ""
-
-        # Print missing modules
-        missing, maybe = self.any_missing_maybe()
-        if missing:
-            print
-            print "Missing modules:"
-            for name in missing:
-                mods = self.badmodules[name].keys()
-                mods.sort()
-                print "?", name, "imported from", ', '.join(mods)
-        # Print modules that may be missing, but then again, maybe not...
-        if maybe:
-            print
-            print "Submodules thay appear to be missing, but could also be",
-            print "global names in the parent package:"
-            for name in maybe:
-                mods = self.badmodules[name].keys()
-                mods.sort()
-                print "?", name, "imported from", ', '.join(mods)
-
-    def any_missing(self):
-        """Return a list of modules that appear to be missing. Use
-        any_missing_maybe() if you want to know which modules are
-        certain to be missing, and which *may* be missing.
-        """
-        missing, maybe = self.any_missing_maybe()
-        return missing + maybe
-
-    def any_missing_maybe(self):
-        """Return two lists, one with modules that are certainly missing
-        and one with modules that *may* be missing. The latter names could
-        either be submodules *or* just global names in the package.
-
-        The reason it can't always be determined is that it's impossible to
-        tell which names are imported when "from module import *" is done
-        with an extension module, short of actually importing it.
-        """
-        missing = []
-        maybe = []
-        for name in self.badmodules:
-            if name in self.excludes:
-                continue
-            i = name.rfind(".")
-            if i < 0:
-                missing.append(name)
-                continue
-            subname = name[i+1:]
-            pkgname = name[:i]
-            pkg = self.modules.get(pkgname)
-            if pkg is not None:
-                if pkgname in self.badmodules[name]:
-                    # The package tried to import this module itself and
-                    # failed. It's definitely missing.
-                    missing.append(name)
-                elif subname in pkg.globalnames:
-                    # It's a global in the package: definitely not missing.
-                    pass
-                elif pkg.starimports:
-                    # It could be missing, but the package did an "import *"
-                    # from a non-Python module, so we simply can't be sure.
-                    maybe.append(name)
-                else:
-                    # It's not a global in the package, the package didn't
-                    # do funny star imports, it's very likely to be missing.
-                    # The symbol could be inserted into the package from the
-                    # outside, but since that's not good style we simply list
-                    # it missing.
-                    missing.append(name)
-            else:
-                missing.append(name)
-        missing.sort()
-        maybe.sort()
-        return missing, maybe
-
-    def replace_paths_in_code(self, co):
-        new_filename = original_filename = os.path.normpath(co.co_filename)
-        for f, r in self.replace_paths:
-            if original_filename.startswith(f):
-                new_filename = r + original_filename[len(f):]
-                break
-
-        if self.debug and original_filename not in self.processed_paths:
-            if new_filename != original_filename:
-                self.msgout(2, "co_filename %r changed to %r" \
-                                    % (original_filename,new_filename,))
-            else:
-                self.msgout(2, "co_filename %r remains unchanged" \
-                                    % (original_filename,))
-            self.processed_paths.append(original_filename)
-
-        consts = list(co.co_consts)
-        for i in range(len(consts)):
-            if isinstance(consts[i], type(co)):
-                consts[i] = self.replace_paths_in_code(consts[i])
-
-        return new.code(co.co_argcount, co.co_nlocals, co.co_stacksize,
-                         co.co_flags, co.co_code, tuple(consts), co.co_names,
-                         co.co_varnames, new_filename, co.co_name,
-                         co.co_firstlineno, co.co_lnotab,
-                         co.co_freevars, co.co_cellvars)
-
-
-def test():
-    # Parse command line
-    import getopt
-    try:
-        opts, args = getopt.getopt(sys.argv[1:], "dmp:qx:")
-    except getopt.error, msg:
-        print msg
-        return
-
-    # Process options
-    debug = 1
-    domods = 0
-    addpath = []
-    exclude = []
-    for o, a in opts:
-        if o == '-d':
-            debug = debug + 1
-        if o == '-m':
-            domods = 1
-        if o == '-p':
-            addpath = addpath + a.split(os.pathsep)
-        if o == '-q':
-            debug = 0
-        if o == '-x':
-            exclude.append(a)
-
-    # Provide default arguments
-    if not args:
-        script = "hello.py"
-    else:
-        script = args[0]
-
-    # Set the path based on sys.path and the script directory
-    path = sys.path[:]
-    path[0] = os.path.dirname(script)
-    path = addpath + path
-    if debug > 1:
-        print "path:"
-        for item in path:
-            print "   ", repr(item)
-
-    # Create the module finder and turn its crank
-    mf = ModuleFinder(path, debug, exclude)
-    for arg in args[1:]:
-        if arg == '-m':
-            domods = 1
-            continue
-        if domods:
-            if arg[-2:] == '.*':
-                mf.import_hook(arg[:-2], None, ["*"])
-            else:
-                mf.import_hook(arg)
-        else:
-            mf.load_file(arg)
-    mf.run_script(script)
-    mf.report()
-    return mf  # for -i debugging
-
-
-if __name__ == '__main__':
-    try:
-        mf = test()
-    except KeyboardInterrupt:
-        print "\n[interrupt]"