home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2006 January / Gamestar_80_2006-01_dvd.iso / Dema / Civilization4 / data1.cab / Civ4DemoComponent / Assets / Python / System / modulefinder.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-11-09  |  16.5 KB  |  664 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Find modules used by a script, using introspection.'''
  5. import dis
  6. import imp
  7. import marshal
  8. import os
  9. import sys
  10. import new
  11. if hasattr(sys.__stdout__, 'newlines'):
  12.     READ_MODE = 'U'
  13. else:
  14.     READ_MODE = 'r'
  15. LOAD_CONST = dis.opname.index('LOAD_CONST')
  16. IMPORT_NAME = dis.opname.index('IMPORT_NAME')
  17. STORE_NAME = dis.opname.index('STORE_NAME')
  18. STORE_GLOBAL = dis.opname.index('STORE_GLOBAL')
  19. STORE_OPS = [
  20.     STORE_NAME,
  21.     STORE_GLOBAL]
  22. packagePathMap = { }
  23.  
  24. def AddPackagePath(packagename, path):
  25.     paths = packagePathMap.get(packagename, [])
  26.     paths.append(path)
  27.     packagePathMap[packagename] = paths
  28.  
  29. replacePackageMap = { }
  30.  
  31. def ReplacePackage(oldname, newname):
  32.     replacePackageMap[oldname] = newname
  33.  
  34.  
  35. class Module:
  36.     
  37.     def __init__(self, name, file = None, path = None):
  38.         self.__name__ = name
  39.         self.__file__ = file
  40.         self.__path__ = path
  41.         self.__code__ = None
  42.         self.globalnames = { }
  43.         self.starimports = { }
  44.  
  45.     
  46.     def __repr__(self):
  47.         s = 'Module(%r' % (self.__name__,)
  48.         if self.__file__ is not None:
  49.             s = s + ', %r' % (self.__file__,)
  50.         
  51.         if self.__path__ is not None:
  52.             s = s + ', %r' % (self.__path__,)
  53.         
  54.         s = s + ')'
  55.         return s
  56.  
  57.  
  58.  
  59. class ModuleFinder:
  60.     
  61.     def __init__(self, path = None, debug = 0, excludes = [], replace_paths = []):
  62.         if path is None:
  63.             path = sys.path
  64.         
  65.         self.path = path
  66.         self.modules = { }
  67.         self.badmodules = { }
  68.         self.debug = debug
  69.         self.indent = 0
  70.         self.excludes = excludes
  71.         self.replace_paths = replace_paths
  72.         self.processed_paths = []
  73.  
  74.     
  75.     def msg(self, level, str, *args):
  76.         if level <= self.debug:
  77.             for i in range(self.indent):
  78.                 print '   ',
  79.             
  80.             print str,
  81.             for arg in args:
  82.                 print repr(arg),
  83.             
  84.             print 
  85.         
  86.  
  87.     
  88.     def msgin(self, *args):
  89.         level = args[0]
  90.         if level <= self.debug:
  91.             self.indent = self.indent + 1
  92.             self.msg(*args)
  93.         
  94.  
  95.     
  96.     def msgout(self, *args):
  97.         level = args[0]
  98.         if level <= self.debug:
  99.             self.indent = self.indent - 1
  100.             self.msg(*args)
  101.         
  102.  
  103.     
  104.     def run_script(self, pathname):
  105.         self.msg(2, 'run_script', pathname)
  106.         fp = open(pathname, READ_MODE)
  107.         stuff = ('', 'r', imp.PY_SOURCE)
  108.         self.load_module('__main__', fp, pathname, stuff)
  109.  
  110.     
  111.     def load_file(self, pathname):
  112.         (dir, name) = os.path.split(pathname)
  113.         (name, ext) = os.path.splitext(name)
  114.         fp = open(pathname, READ_MODE)
  115.         stuff = (ext, 'r', imp.PY_SOURCE)
  116.         self.load_module(name, fp, pathname, stuff)
  117.  
  118.     
  119.     def import_hook(self, name, caller = None, fromlist = None):
  120.         self.msg(3, 'import_hook', name, caller, fromlist)
  121.         parent = self.determine_parent(caller)
  122.         (q, tail) = self.find_head_package(parent, name)
  123.         m = self.load_tail(q, tail)
  124.         if not fromlist:
  125.             return q
  126.         
  127.         if m.__path__:
  128.             self.ensure_fromlist(m, fromlist)
  129.         
  130.  
  131.     
  132.     def determine_parent(self, caller):
  133.         self.msgin(4, 'determine_parent', caller)
  134.         if not caller:
  135.             self.msgout(4, 'determine_parent -> None')
  136.             return None
  137.         
  138.         pname = caller.__name__
  139.         if caller.__path__:
  140.             parent = self.modules[pname]
  141.             if not caller is parent:
  142.                 raise AssertionError
  143.             self.msgout(4, 'determine_parent ->', parent)
  144.             return parent
  145.         
  146.         if '.' in pname:
  147.             i = pname.rfind('.')
  148.             pname = pname[:i]
  149.             parent = self.modules[pname]
  150.             if not parent.__name__ == pname:
  151.                 raise AssertionError
  152.             self.msgout(4, 'determine_parent ->', parent)
  153.             return parent
  154.         
  155.         self.msgout(4, 'determine_parent -> None')
  156.  
  157.     
  158.     def find_head_package(self, parent, name):
  159.         self.msgin(4, 'find_head_package', parent, name)
  160.         if '.' in name:
  161.             i = name.find('.')
  162.             head = name[:i]
  163.             tail = name[i + 1:]
  164.         else:
  165.             head = name
  166.             tail = ''
  167.         if parent:
  168.             qname = '%s.%s' % (parent.__name__, head)
  169.         else:
  170.             qname = head
  171.         q = self.import_module(head, qname, parent)
  172.         if q:
  173.             self.msgout(4, 'find_head_package ->', (q, tail))
  174.             return (q, tail)
  175.         
  176.         if parent:
  177.             qname = head
  178.             parent = None
  179.             q = self.import_module(head, qname, parent)
  180.             if q:
  181.                 self.msgout(4, 'find_head_package ->', (q, tail))
  182.                 return (q, tail)
  183.             
  184.         
  185.         self.msgout(4, 'raise ImportError: No module named', qname)
  186.         raise ImportError, 'No module named ' + qname
  187.  
  188.     
  189.     def load_tail(self, q, tail):
  190.         self.msgin(4, 'load_tail', q, tail)
  191.         m = q
  192.         while tail:
  193.             i = tail.find('.')
  194.             if i < 0:
  195.                 i = len(tail)
  196.             
  197.             head = tail[:i]
  198.             tail = tail[i + 1:]
  199.             mname = '%s.%s' % (m.__name__, head)
  200.             m = self.import_module(head, mname, m)
  201.             if not m:
  202.                 self.msgout(4, 'raise ImportError: No module named', mname)
  203.                 raise ImportError, 'No module named ' + mname
  204.                 continue
  205.         self.msgout(4, 'load_tail ->', m)
  206.         return m
  207.  
  208.     
  209.     def ensure_fromlist(self, m, fromlist, recursive = 0):
  210.         self.msg(4, 'ensure_fromlist', m, fromlist, recursive)
  211.         for sub in fromlist:
  212.             if sub == '*':
  213.                 if not recursive:
  214.                     all = self.find_all_submodules(m)
  215.                     if all:
  216.                         self.ensure_fromlist(m, all, 1)
  217.                     
  218.                 
  219.             recursive
  220.             if not hasattr(m, sub):
  221.                 subname = '%s.%s' % (m.__name__, sub)
  222.                 submod = self.import_module(sub, subname, m)
  223.                 if not submod:
  224.                     raise ImportError, 'No module named ' + subname
  225.                 
  226.             submod
  227.         
  228.  
  229.     
  230.     def find_all_submodules(self, m):
  231.         if not m.__path__:
  232.             return None
  233.         
  234.         modules = { }
  235.         suffixes = []
  236.         for triple in imp.get_suffixes():
  237.             suffixes.append(triple[0])
  238.         
  239.         for dir in m.__path__:
  240.             
  241.             try:
  242.                 names = os.listdir(dir)
  243.             except os.error:
  244.                 self.msg(2, "can't list directory", dir)
  245.                 continue
  246.  
  247.             for name in names:
  248.                 mod = None
  249.                 for suff in suffixes:
  250.                     n = len(suff)
  251.                     if name[-n:] == suff:
  252.                         mod = name[:-n]
  253.                         break
  254.                         continue
  255.                 
  256.                 if mod and mod != '__init__':
  257.                     modules[mod] = mod
  258.                     continue
  259.             
  260.         
  261.         return modules.keys()
  262.  
  263.     
  264.     def import_module(self, partname, fqname, parent):
  265.         self.msgin(3, 'import_module', partname, fqname, parent)
  266.         
  267.         try:
  268.             m = self.modules[fqname]
  269.         except KeyError:
  270.             pass
  271.  
  272.         self.msgout(3, 'import_module ->', m)
  273.         return m
  274.         if self.badmodules.has_key(fqname):
  275.             self.msgout(3, 'import_module -> None')
  276.             return None
  277.         
  278.         if parent and parent.__path__ is None:
  279.             self.msgout(3, 'import_module -> None')
  280.             return None
  281.         
  282.         
  283.         try:
  284.             if parent:
  285.                 pass
  286.             (fp, pathname, stuff) = self.find_module(partname, parent.__path__, parent)
  287.         except ImportError:
  288.             self.msgout(3, 'import_module ->', None)
  289.             return None
  290.  
  291.         
  292.         try:
  293.             m = self.load_module(fqname, fp, pathname, stuff)
  294.         finally:
  295.             if fp:
  296.                 fp.close()
  297.             
  298.  
  299.         if parent:
  300.             setattr(parent, partname, m)
  301.         
  302.         self.msgout(3, 'import_module ->', m)
  303.         return m
  304.  
  305.     
  306.     def load_module(self, fqname, fp, pathname, .8):
  307.         (suffix, mode, type) = .8
  308.         if fp:
  309.             pass
  310.         self.msgin(2, 'load_module', fqname, 'fp', pathname)
  311.         if type == imp.PKG_DIRECTORY:
  312.             m = self.load_package(fqname, pathname)
  313.             self.msgout(2, 'load_module ->', m)
  314.             return m
  315.         
  316.         if type == imp.PY_SOURCE:
  317.             co = compile(fp.read() + '\n', pathname, 'exec')
  318.         elif type == imp.PY_COMPILED:
  319.             if fp.read(4) != imp.get_magic():
  320.                 self.msgout(2, 'raise ImportError: Bad magic number', pathname)
  321.                 raise ImportError, 'Bad magic number in %s' % pathname
  322.             
  323.             fp.read(4)
  324.             co = marshal.load(fp)
  325.         else:
  326.             co = None
  327.         m = self.add_module(fqname)
  328.         m.__file__ = pathname
  329.         if co:
  330.             if self.replace_paths:
  331.                 co = self.replace_paths_in_code(co)
  332.             
  333.             m.__code__ = co
  334.             self.scan_code(co, m)
  335.         
  336.         self.msgout(2, 'load_module ->', m)
  337.         return m
  338.  
  339.     
  340.     def _add_badmodule(self, name, caller):
  341.         if name not in self.badmodules:
  342.             self.badmodules[name] = { }
  343.         
  344.         self.badmodules[name][caller.__name__] = 1
  345.  
  346.     
  347.     def _safe_import_hook(self, name, caller, fromlist):
  348.         if name in self.badmodules:
  349.             self._add_badmodule(name, caller)
  350.             return None
  351.         
  352.         
  353.         try:
  354.             self.import_hook(name, caller)
  355.         except ImportError:
  356.             msg = None
  357.             self.msg(2, 'ImportError:', str(msg))
  358.             self._add_badmodule(name, caller)
  359.  
  360.         if fromlist:
  361.             for sub in fromlist:
  362.                 if sub in self.badmodules:
  363.                     self._add_badmodule(sub, caller)
  364.                     continue
  365.                 
  366.                 
  367.                 try:
  368.                     self.import_hook(name, caller, [
  369.                         sub])
  370.                 continue
  371.                 except ImportError:
  372.                     msg = None
  373.                     self.msg(2, 'ImportError:', str(msg))
  374.                     fullname = name + '.' + sub
  375.                     self._add_badmodule(fullname, caller)
  376.                     continue
  377.                 
  378.  
  379.             
  380.         
  381.  
  382.     
  383.     def scan_code(self, co, m):
  384.         code = co.co_code
  385.         n = len(code)
  386.         i = 0
  387.         fromlist = None
  388.         while i < n:
  389.             c = code[i]
  390.             i = i + 1
  391.             op = ord(c)
  392.             if op >= dis.HAVE_ARGUMENT:
  393.                 oparg = ord(code[i]) + ord(code[i + 1]) * 256
  394.                 i = i + 2
  395.             
  396.             if op == LOAD_CONST:
  397.                 fromlist = co.co_consts[oparg]
  398.                 continue
  399.             if op == IMPORT_NAME:
  400.                 if not fromlist is None and type(fromlist) is tuple:
  401.                     raise AssertionError
  402.                 name = co.co_names[oparg]
  403.                 have_star = 0
  404.                 self._safe_import_hook(name, m, fromlist)
  405.                 if have_star:
  406.                     mm = None
  407.                     if m.__path__:
  408.                         mm = self.modules.get(m.__name__ + '.' + name)
  409.                     
  410.                     if mm is None:
  411.                         mm = self.modules.get(name)
  412.                     
  413.                     if mm is not None:
  414.                         m.globalnames.update(mm.globalnames)
  415.                         m.starimports.update(mm.starimports)
  416.                         if mm.__code__ is None:
  417.                             m.starimports[name] = 1
  418.                         
  419.                     else:
  420.                         m.starimports[name] = 1
  421.                 
  422.             have_star
  423.             if op in STORE_OPS:
  424.                 name = co.co_names[oparg]
  425.                 m.globalnames[name] = 1
  426.                 continue
  427.             None if fromlist is not None else []
  428.         for c in co.co_consts:
  429.             if isinstance(c, type(co)):
  430.                 self.scan_code(c, m)
  431.                 continue
  432.         
  433.  
  434.     
  435.     def load_package(self, fqname, pathname):
  436.         self.msgin(2, 'load_package', fqname, pathname)
  437.         newname = replacePackageMap.get(fqname)
  438.         if newname:
  439.             fqname = newname
  440.         
  441.         m = self.add_module(fqname)
  442.         m.__file__ = pathname
  443.         m.__path__ = [
  444.             pathname]
  445.         m.__path__ = m.__path__ + packagePathMap.get(fqname, [])
  446.         (fp, buf, stuff) = self.find_module('__init__', m.__path__)
  447.         self.load_module(fqname, fp, buf, stuff)
  448.         self.msgout(2, 'load_package ->', m)
  449.         return m
  450.  
  451.     
  452.     def add_module(self, fqname):
  453.         if self.modules.has_key(fqname):
  454.             return self.modules[fqname]
  455.         
  456.         self.modules[fqname] = m = Module(fqname)
  457.         return m
  458.  
  459.     
  460.     def find_module(self, name, path, parent = None):
  461.         if parent is not None:
  462.             fullname = parent.__name__ + '.' + name
  463.         else:
  464.             fullname = name
  465.         if fullname in self.excludes:
  466.             self.msgout(3, 'find_module -> Excluded', fullname)
  467.             raise ImportError, name
  468.         
  469.         if path is None:
  470.             if name in sys.builtin_module_names:
  471.                 return (None, None, ('', '', imp.C_BUILTIN))
  472.             
  473.             path = self.path
  474.         
  475.         return imp.find_module(name, path)
  476.  
  477.     
  478.     def report(self):
  479.         '''Print a report to stdout, listing the found modules with their
  480.         paths, as well as modules that are missing, or seem to be missing.
  481.         '''
  482.         print 
  483.         print '  %-25s %s' % ('Name', 'File')
  484.         print '  %-25s %s' % ('----', '----')
  485.         keys = self.modules.keys()
  486.         keys.sort()
  487.         for key in keys:
  488.             m = self.modules[key]
  489.             if m.__path__:
  490.                 print 'P',
  491.             else:
  492.                 print 'm',
  493.             print '%-25s' % key,
  494.             if not m.__file__:
  495.                 pass
  496.             print ''
  497.         
  498.         (missing, maybe) = self.any_missing_maybe()
  499.         if missing:
  500.             print 
  501.             print 'Missing modules:'
  502.             for name in missing:
  503.                 mods = self.badmodules[name].keys()
  504.                 mods.sort()
  505.                 print '?', name, 'imported from', ', '.join(mods)
  506.             
  507.         
  508.         if maybe:
  509.             print 
  510.             print 'Submodules thay appear to be missing, but could also be', 'global names in the parent package:'
  511.             for name in maybe:
  512.                 mods = self.badmodules[name].keys()
  513.                 mods.sort()
  514.                 print '?', name, 'imported from', ', '.join(mods)
  515.             
  516.         
  517.  
  518.     
  519.     def any_missing(self):
  520.         '''Return a list of modules that appear to be missing. Use
  521.         any_missing_maybe() if you want to know which modules are
  522.         certain to be missing, and which *may* be missing.
  523.         '''
  524.         (missing, maybe) = self.any_missing_maybe()
  525.         return missing + maybe
  526.  
  527.     
  528.     def any_missing_maybe(self):
  529.         '''Return two lists, one with modules that are certainly missing
  530.         and one with modules that *may* be missing. The latter names could
  531.         either be submodules *or* just global names in the package.
  532.  
  533.         The reason it can\'t always be determined is that it\'s impossible to
  534.         tell which names are imported when "from module import *" is done
  535.         with an extension module, short of actually importing it.
  536.         '''
  537.         missing = []
  538.         maybe = []
  539.         for name in self.badmodules:
  540.             if name in self.excludes:
  541.                 continue
  542.             
  543.             i = name.rfind('.')
  544.             if i < 0:
  545.                 missing.append(name)
  546.                 continue
  547.             
  548.             subname = name[i + 1:]
  549.             pkgname = name[:i]
  550.             pkg = self.modules.get(pkgname)
  551.             if pkg is not None:
  552.                 if pkgname in self.badmodules[name]:
  553.                     missing.append(name)
  554.                 elif subname in pkg.globalnames:
  555.                     pass
  556.                 elif pkg.starimports:
  557.                     maybe.append(name)
  558.                 else:
  559.                     missing.append(name)
  560.             pkgname in self.badmodules[name]
  561.             missing.append(name)
  562.         
  563.         missing.sort()
  564.         maybe.sort()
  565.         return (missing, maybe)
  566.  
  567.     
  568.     def replace_paths_in_code(self, co):
  569.         new_filename = original_filename = os.path.normpath(co.co_filename)
  570.         for f, r in self.replace_paths:
  571.             if original_filename.startswith(f):
  572.                 new_filename = r + original_filename[len(f):]
  573.                 break
  574.                 continue
  575.         
  576.         if self.debug and original_filename not in self.processed_paths:
  577.             if new_filename != original_filename:
  578.                 self.msgout(2, 'co_filename %r changed to %r' % (original_filename, new_filename))
  579.             else:
  580.                 self.msgout(2, 'co_filename %r remains unchanged' % (original_filename,))
  581.             self.processed_paths.append(original_filename)
  582.         
  583.         consts = list(co.co_consts)
  584.         for i in range(len(consts)):
  585.             if isinstance(consts[i], type(co)):
  586.                 consts[i] = self.replace_paths_in_code(consts[i])
  587.                 continue
  588.         
  589.         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)
  590.  
  591.  
  592.  
  593. def test():
  594.     import getopt
  595.     
  596.     try:
  597.         (opts, args) = getopt.getopt(sys.argv[1:], 'dmp:qx:')
  598.     except getopt.error:
  599.         msg = None
  600.         print msg
  601.         return None
  602.  
  603.     debug = 1
  604.     domods = 0
  605.     addpath = []
  606.     exclude = []
  607.     for o, a in opts:
  608.         if o == '-d':
  609.             debug = debug + 1
  610.         
  611.         if o == '-m':
  612.             domods = 1
  613.         
  614.         if o == '-p':
  615.             addpath = addpath + a.split(os.pathsep)
  616.         
  617.         if o == '-q':
  618.             debug = 0
  619.         
  620.         if o == '-x':
  621.             exclude.append(a)
  622.             continue
  623.     
  624.     if not args:
  625.         script = 'hello.py'
  626.     else:
  627.         script = args[0]
  628.     path = sys.path[:]
  629.     path[0] = os.path.dirname(script)
  630.     path = addpath + path
  631.     if debug > 1:
  632.         print 'path:'
  633.         for item in path:
  634.             print '   ', repr(item)
  635.         
  636.     
  637.     mf = ModuleFinder(path, debug, exclude)
  638.     for arg in args[1:]:
  639.         if arg == '-m':
  640.             domods = 1
  641.             continue
  642.         
  643.         if domods:
  644.             if arg[-2:] == '.*':
  645.                 mf.import_hook(arg[:-2], None, [
  646.                     '*'])
  647.             else:
  648.                 mf.import_hook(arg)
  649.         arg[-2:] == '.*'
  650.         mf.load_file(arg)
  651.     
  652.     mf.run_script(script)
  653.     mf.report()
  654.     return mf
  655.  
  656. if __name__ == '__main__':
  657.     
  658.     try:
  659.         mf = test()
  660.     except KeyboardInterrupt:
  661.         print '\n[interrupt]'
  662.  
  663.  
  664.