home *** CD-ROM | disk | FTP | other *** search
/ com!online 2005 April / com_0405_1.iso / opensource / BTpp-0.5.4-bin.exe / $INSTDIR / BT++.exe / imputil.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2003-04-19  |  14.8 KB  |  448 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.2)
  3.  
  4. import imp
  5. import sys
  6. import __builtin__
  7. import struct
  8. import marshal
  9. __all__ = [
  10.     'ImportManager',
  11.     'Importer',
  12.     'BuiltinImporter']
  13. _StringType = type('')
  14. _ModuleType = type(sys)
  15.  
  16. class ImportManager:
  17.     
  18.     def install(self, namespace = vars(__builtin__)):
  19.         if isinstance(namespace, _ModuleType):
  20.             namespace = vars(namespace)
  21.         
  22.         self.previous_importer = namespace['__import__']
  23.         self.namespace = namespace
  24.         namespace['__import__'] = self._import_hook
  25.  
  26.     
  27.     def uninstall(self):
  28.         self.namespace['__import__'] = self.previous_importer
  29.  
  30.     
  31.     def add_suffix(self, suffix, importFunc):
  32.         self.fs_imp.add_suffix(suffix, importFunc)
  33.  
  34.     clsFilesystemImporter = None
  35.     
  36.     def __init__(self, fs_imp = None):
  37.         if not _os_stat:
  38.             _os_bootstrap()
  39.         
  40.         if not fs_imp:
  41.             if not self.clsFilesystemImporter:
  42.                 pass
  43.             cls = _FilesystemImporter
  44.             fs_imp = cls()
  45.         
  46.         self.fs_imp = fs_imp
  47.         for desc in imp.get_suffixes():
  48.             if desc[2] == imp.C_EXTENSION:
  49.                 self.add_suffix(desc[0], DynLoadSuffixImporter(desc).import_file)
  50.             
  51.         
  52.         self.add_suffix('.py', py_suffix_importer)
  53.  
  54.     
  55.     def _import_hook(self, fqname, globals = None, locals = None, fromlist = None):
  56.         parts = fqname.split('.')
  57.         parent = self._determine_import_context(globals)
  58.         if parent:
  59.             module = parent.__importer__._do_import(parent, parts, fromlist)
  60.             if module:
  61.                 return module
  62.             
  63.         
  64.         
  65.         try:
  66.             top_module = sys.modules[parts[0]]
  67.         except KeyError:
  68.             top_module = self._import_top_module(parts[0])
  69.             if not top_module:
  70.                 raise ImportError, 'No module named ' + fqname
  71.             
  72.         except:
  73.             not top_module
  74.  
  75.         if len(parts) == 1:
  76.             if not fromlist:
  77.                 return top_module
  78.             
  79.             if not top_module.__dict__.get('__ispkg__'):
  80.                 return top_module
  81.             
  82.         
  83.         importer = top_module.__dict__.get('__importer__')
  84.         if importer:
  85.             return importer._finish_import(top_module, parts[1:], fromlist)
  86.         
  87.         if len(parts) == 2 and hasattr(top_module, parts[1]):
  88.             return top_module
  89.         
  90.         raise ImportError, 'No module named ' + fqname
  91.  
  92.     
  93.     def _determine_import_context(self, globals):
  94.         if not globals or not globals.get('__importer__'):
  95.             return None
  96.         
  97.         parent_fqname = globals['__name__']
  98.         if globals['__ispkg__']:
  99.             parent = sys.modules[parent_fqname]
  100.             return parent
  101.         
  102.         i = parent_fqname.rfind('.')
  103.         if i == -1:
  104.             return None
  105.         
  106.         parent_fqname = parent_fqname[:i]
  107.         parent = sys.modules[parent_fqname]
  108.         return parent
  109.  
  110.     
  111.     def _import_top_module(self, name):
  112.         for item in sys.path:
  113.             if isinstance(item, _StringType):
  114.                 module = self.fs_imp.import_from_dir(item, name)
  115.             else:
  116.                 module = item.import_top(name)
  117.             if module:
  118.                 return module
  119.             
  120.         
  121.         return None
  122.  
  123.     
  124.     def _reload_hook(self, module):
  125.         importer = module.__dict__.get('__importer__')
  126.         if not importer:
  127.             pass
  128.         
  129.         raise SystemError, 'reload not yet implemented'
  130.  
  131.  
  132.  
  133. class Importer:
  134.     
  135.     def import_top(self, name):
  136.         return self._import_one(None, name, name)
  137.  
  138.     
  139.     def _finish_import(self, top, parts, fromlist):
  140.         bottom = self._load_tail(top, parts)
  141.         if not fromlist:
  142.             return top
  143.         
  144.         if bottom.__ispkg__:
  145.             self._import_fromlist(bottom, fromlist)
  146.         
  147.         return bottom
  148.  
  149.     
  150.     def _import_one(self, parent, modname, fqname):
  151.         
  152.         try:
  153.             return sys.modules[fqname]
  154.         except KeyError:
  155.             pass
  156.  
  157.         result = self.get_code(parent, modname, fqname)
  158.         if result is None:
  159.             return None
  160.         
  161.         module = self._process_result(result, fqname)
  162.         if parent:
  163.             setattr(parent, modname, module)
  164.         
  165.         return module
  166.  
  167.     
  168.     def _process_result(self, .2, fqname):
  169.         (ispkg, code, values) = .2
  170.         is_module = isinstance(code, _ModuleType)
  171.         if is_module:
  172.             module = code
  173.         else:
  174.             module = imp.new_module(fqname)
  175.         module.__importer__ = self
  176.         module.__ispkg__ = ispkg
  177.         module.__dict__.update(values)
  178.         sys.modules[fqname] = module
  179.         if not is_module:
  180.             exec code in module.__dict__
  181.         
  182.         module = sys.modules[fqname]
  183.         module.__name__ = fqname
  184.         return module
  185.  
  186.     
  187.     def _load_tail(self, m, parts):
  188.         for part in parts:
  189.             fqname = '%s.%s' % (m.__name__, part)
  190.             m = self._import_one(m, part, fqname)
  191.             if not m:
  192.                 raise ImportError, 'No module named ' + fqname
  193.             
  194.         
  195.         return m
  196.  
  197.     
  198.     def _import_fromlist(self, package, fromlist):
  199.         if '*' in fromlist:
  200.             fromlist = list(fromlist) + list(package.__dict__.get('__all__', []))
  201.         
  202.         for sub in fromlist:
  203.             if sub != '*' and not hasattr(package, sub):
  204.                 subname = '%s.%s' % (package.__name__, sub)
  205.                 submod = self._import_one(package, sub, subname)
  206.                 if not submod:
  207.                     raise ImportError, 'cannot import name ' + subname
  208.                 
  209.             
  210.         
  211.  
  212.     
  213.     def _do_import(self, parent, parts, fromlist):
  214.         top_name = parts[0]
  215.         top_fqname = parent.__name__ + '.' + top_name
  216.         top_module = self._import_one(parent, top_name, top_fqname)
  217.         if not top_module:
  218.             return None
  219.         
  220.         return self._finish_import(top_module, parts[1:], fromlist)
  221.  
  222.     
  223.     def get_code(self, parent, modname, fqname):
  224.         raise RuntimeError, 'get_code not implemented'
  225.  
  226.  
  227. if not __debug__ and 'c':
  228.     pass
  229. _suffix_char = 'o'
  230. _suffix = '.py' + _suffix_char
  231.  
  232. def _compile(pathname, timestamp):
  233.     codestring = open(pathname, 'r').read()
  234.     if codestring and codestring[-1] != '\n':
  235.         codestring = codestring + '\n'
  236.     
  237.     code = __builtin__.compile(codestring, pathname, 'exec')
  238.     
  239.     try:
  240.         f = open(pathname + _suffix_char, 'wb')
  241.     except IOError:
  242.         pass
  243.  
  244.     f.write('\x00\x00\x00\x00')
  245.     f.write(struct.pack('<I', timestamp))
  246.     marshal.dump(code, f)
  247.     f.flush()
  248.     f.seek(0, 0)
  249.     f.write(imp.get_magic())
  250.     f.close()
  251.     return code
  252.  
  253. _os_stat = _os_path_join = None
  254.  
  255. def _os_bootstrap():
  256.     global _os_stat, _os_path_join
  257.     names = sys.builtin_module_names
  258.     join = None
  259.     if 'posix' in names:
  260.         sep = '/'
  261.         stat = stat
  262.         import posix
  263.     elif 'nt' in names:
  264.         sep = '\\'
  265.         stat = stat
  266.         import nt
  267.     elif 'dos' in names:
  268.         sep = '\\'
  269.         stat = stat
  270.         import dos
  271.     elif 'os2' in names:
  272.         sep = '\\'
  273.         stat = stat
  274.         import os2
  275.     elif 'mac' in names:
  276.         stat = stat
  277.         import mac
  278.         
  279.         def join(a, b):
  280.             if a == '':
  281.                 return b
  282.             
  283.             path = s
  284.             if ':' not in a:
  285.                 a = ':' + a
  286.             
  287.             if a[-1:] != ':':
  288.                 a = a + ':'
  289.             
  290.             return a + b
  291.  
  292.     else:
  293.         raise ImportError, 'no os specific module found'
  294.     if join is None:
  295.         
  296.         def join(a, b, sep = sep):
  297.             if a == '':
  298.                 return b
  299.             
  300.             lastchar = a[-1:]
  301.             if lastchar == '/' or lastchar == sep:
  302.                 return a + b
  303.             
  304.             return a + sep + b
  305.  
  306.     
  307.     _os_stat = stat
  308.     _os_path_join = join
  309.  
  310.  
  311. def _os_path_isdir(pathname):
  312.     
  313.     try:
  314.         s = _os_stat(pathname)
  315.     except OSError:
  316.         return None
  317.  
  318.     return s[0] & 61440 == 16384
  319.  
  320.  
  321. def _timestamp(pathname):
  322.     
  323.     try:
  324.         s = _os_stat(pathname)
  325.     except OSError:
  326.         return None
  327.  
  328.     return long(s[8])
  329.  
  330.  
  331. class BuiltinImporter(Importer):
  332.     
  333.     def get_code(self, parent, modname, fqname):
  334.         if parent:
  335.             return None
  336.         
  337.         if imp.is_builtin(modname):
  338.             type = imp.C_BUILTIN
  339.         elif imp.is_frozen(modname):
  340.             type = imp.PY_FROZEN
  341.         else:
  342.             return None
  343.         module = imp.load_module(modname, None, modname, ('', '', type))
  344.         return (0, module, { })
  345.  
  346.  
  347.  
  348. class _FilesystemImporter(Importer):
  349.     
  350.     def __init__(self):
  351.         self.suffixes = []
  352.  
  353.     
  354.     def add_suffix(self, suffix, importFunc):
  355.         self.suffixes.append((suffix, importFunc))
  356.  
  357.     
  358.     def import_from_dir(self, dir, fqname):
  359.         result = self._import_pathname(_os_path_join(dir, fqname), fqname)
  360.         if result:
  361.             return self._process_result(result, fqname)
  362.         
  363.         return None
  364.  
  365.     
  366.     def get_code(self, parent, modname, fqname):
  367.         return self._import_pathname(_os_path_join(parent.__pkgdir__, modname), fqname)
  368.  
  369.     
  370.     def _import_pathname(self, pathname, fqname):
  371.         if _os_path_isdir(pathname):
  372.             result = self._import_pathname(_os_path_join(pathname, '__init__'), fqname)
  373.             if result:
  374.                 values = result[2]
  375.                 values['__pkgdir__'] = pathname
  376.                 values['__path__'] = [
  377.                     pathname]
  378.                 return (1, result[1], values)
  379.             
  380.             return None
  381.         
  382.         for suffix, importFunc in self.suffixes:
  383.             filename = pathname + suffix
  384.             
  385.             try:
  386.                 finfo = _os_stat(filename)
  387.             except OSError:
  388.                 pass
  389.  
  390.             return importFunc(filename, finfo, fqname)
  391.         
  392.         return None
  393.  
  394.  
  395.  
  396. def py_suffix_importer(filename, finfo, fqname):
  397.     file = filename[:-3] + _suffix
  398.     t_py = long(finfo[8])
  399.     t_pyc = _timestamp(file)
  400.     code = None
  401.     if t_pyc is not None and t_pyc >= t_py:
  402.         f = open(file, 'rb')
  403.         if f.read(4) == imp.get_magic():
  404.             t = struct.unpack('<I', f.read(4))[0]
  405.             if t == t_py:
  406.                 code = marshal.load(f)
  407.             
  408.         
  409.         f.close()
  410.     
  411.     if code is None:
  412.         file = filename
  413.         code = _compile(file, t_py)
  414.     
  415.     return (0, code, {
  416.         '__file__': file })
  417.  
  418.  
  419. class DynLoadSuffixImporter:
  420.     
  421.     def __init__(self, desc):
  422.         self.desc = desc
  423.  
  424.     
  425.     def import_file(self, filename, finfo, fqname):
  426.         fp = open(filename, self.desc[1])
  427.         module = imp.load_module(fqname, fp, filename, self.desc)
  428.         module.__file__ = filename
  429.         return (0, module, { })
  430.  
  431.  
  432.  
  433. def _print_importers():
  434.     items = sys.modules.items()
  435.     items.sort()
  436.     for name, module in items:
  437.         if module:
  438.             print name, module.__dict__.get('__importer__', '-- no importer')
  439.         else:
  440.             print name, '-- non-existent module'
  441.     
  442.  
  443.  
  444. def _test_revamp():
  445.     ImportManager().install()
  446.     sys.path.insert(0, BuiltinImporter())
  447.  
  448.