#!/usr/bin/env python  """ The micropython package for processing Python source code. The code originates from the simplify package but has had various details related to that package removed.  Copyright (C) 2006, 2007, 2008 Paul Boddie <paul@boddie.org.uk>  This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.  --------  To use this module, an importer should be constructed and the load_from_file method used. Here, the standard path for module searching is employed:  importer = Importer(sys.path) importer.load_from_file(filename) importer.vacuum()  Such importer objects are the most convenient mechanism through which the functionality of the micropython package may be accessed. """  from micropython.common import * import micropython.ast import micropython.inspect import micropython.table import os try:     set except NameError:     from sets import Set as set  class Importer:      """     An import machine, searching for and loading modules. In addition, this     class supports the generation of a program image.     """      supported_optimisations = micropython.ast.Translation.supported_optimisations      def __init__(self, path=None, verbose=0):          """         Initialise the importer with the given search 'path' - a list of         directories to search for Python modules.          The optional 'verbose' parameter causes output concerning the activities         of the object to be produced if set to a true value (not the default).         """          self.path = path or [os.getcwd()]         self.verbose = verbose         self.modules = {}         self.modules_ordered = []         self.loading = set()          # Remember the tables once generated.          self.objtable = None         self.paramtable = None         self.clstable = None          # Constant records.          self.constant_values = {}         self.constant_list = None # cache for constants          # Main program information.          self.code = None         self.code_location = None      def constants(self):          "Return a list of constants."          if self.constant_list is None:             self.constant_list = list(self.constant_values.values())          return self.constant_list      def vacuum(self):          "Tidy up the modules."          for name, module in self.modules.items():             if module.loaded:                 module.vacuum()             else:                 del self.modules[name]      def finalise(self):          "Finalise the program."          for module in self.get_modules():              # Fix the attributes.              module.finalise_attributes()              for obj in module.all_objects:                 if isinstance(obj, (micropython.inspect.Class, micropython.inspect.Function)):                     obj.finalise_attributes()      def get_modules(self):          "Return all modules known to the importer."          return self.modules.values()      def get_image(self, with_builtins=0, optimisations=None):          "Return a dictionary mapping modules to structures."          if self.code is not None:             return self.code          objtable = self.get_object_table()         paramtable = self.get_parameter_table()         self.finalise()          image = []          # Append constants to the image.          for pos, const in enumerate(self.constants()):             const.location = pos             image.append(const)          last_module = self.modules_ordered[-1]          for module in self.modules_ordered:              if not with_builtins and module.name == "__builtins__":                 continue              pos = len(image)              # Position the module in the image and make a translation.              module.location = pos             trans = micropython.ast.Translation(module, self, optimisations)              # Add header details.              image.append(module)             pos += 1              # Append module attributes to the image.              attributes = module.module_attributes()             image += module.attributes_as_list()             pos += len(attributes.keys())              # Append classes and functions to the image.              for obj in module.all_objects:                 if isinstance(obj, micropython.inspect.Class):                      # Position the class in the image.                      obj.location = pos                      # Add header details.                      image.append(obj)                     pos += 1                      # Append class attributes to the image.                      attributes = obj.class_attributes()                     image += obj.attributes_as_list()                     pos += len(attributes.keys())                      # Generate the instantiator/initialiser.                     # Append the function code to the image.                      instantiator = obj.get_instantiator()                     instantiator.code_location = pos                     code = trans.get_instantiator_code(obj)                     image += code                     pos += len(code)                      # Class-level code is generated separately at the module                     # level, and the code location is set within the code                     # generation process for the module.                  elif isinstance(obj, micropython.inspect.Function):                      # Position the function in the image.                      obj.location = pos                      # Add header details.                      image.append(obj)                     pos += 1                      # Append any default values to the image.                     # Only do this for named functions (not lambdas).                      if obj.name is not None:                         image += obj.default_attrs                         pos += len(obj.default_attrs)                      # Append the function code to the image.                      obj.code_location = pos                     code = trans.get_code(obj)                     image += code                     pos += len(code)              # Remember the position of the module code.              module.code_location = pos              # Append the module top-level code to the image.              code = trans.get_module_code(final=(module is last_module))             image += code             pos += len(code)          # Remember the generated code and the location of the first instruction.          self.code = image         self.code_location = self.modules["__main__"].code_location         return image      def get_object_table(self):          "Return a table with details of attributes for classes and modules."          if self.objtable is None:             t = self.objtable = micropython.table.ObjectTable()             for module in self.get_modules():                 t.add(module.full_name(), module.module_attributes())                  # Add class and instance attributes for all classes, together                 # with descendant information.                  for obj in module.all_objects:                     if isinstance(obj, micropython.inspect.Class):                         attributes = {obj.full_name() : obj}                         attributes.update(obj.all_attributes())                         attributes.update(obj.all_descendants())                         t.add(obj.full_name(), attributes)          return self.objtable      def get_parameter_table(self):          "Return a table with details of parameters for functions and methods."          # Need the object table to get at class details.          objtable = self.get_object_table()          if self.paramtable is None:             t = self.paramtable = micropython.table.ParameterTable()              # Visit each module, getting function and method details.              for module in self.get_modules():                 for obj in module.all_objects:                     if isinstance(obj, micropython.inspect.Function):                         t.add(obj.full_name(), obj.parameters())                      # Classes are callable, too.                     # Take details of the appropriate __init__ method to make an                     # entry for an instantiation function for the class.                      elif isinstance(obj, micropython.inspect.Class):                         t.add(obj.full_name(), obj.get_instantiator().parameters())              # Filter out all parameter table entries not referenced by keyword             # arguments.              keyword_names = set()              for module in self.get_modules():                 keyword_names.update(module.keyword_names)              for function_name, parameters in t.table.items():                 for name in parameters.keys():                     if name in keyword_names:                         break                 else:                     del t.table[function_name]          return self.paramtable      # Import methods.      def find_in_path(self, name):          """         Find the given module 'name' in the search path, returning None where no         such module could be found, or a 2-tuple from the 'find' method         otherwise.         """          for d in self.path:             m = self.find(d, name)             if m: return m         return None      def find(self, d, name):          """         In the directory 'd', find the given module 'name', where 'name' can         either refer to a single file module or to a package. Return None if the         'name' cannot be associated with either a file or a package directory,         or a 2-tuple from '_find_package' or '_find_module' otherwise.         """          m = self._find_package(d, name)         if m: return m         m = self._find_module(d, name)         if m: return m         return None      def _find_module(self, d, name):          """         In the directory 'd', find the given module 'name', returning None where         no suitable file exists in the directory, or a 2-tuple consisting of         None (indicating that no package directory is involved) and a filename         indicating the location of the module.         """          name_py = name + os.extsep + "py"         filename = self._find_file(d, name_py)         if filename:             return None, filename         return None      def _find_package(self, d, name):          """         In the directory 'd', find the given package 'name', returning None         where no suitable package directory exists, or a 2-tuple consisting of         a directory (indicating the location of the package directory itself)         and a filename indicating the location of the __init__.py module which         declares the package's top-level contents.         """          filename = self._find_file(d, name)         if filename:             init_py = "__init__" + os.path.extsep + "py"             init_py_filename = self._find_file(filename, init_py)             if init_py_filename:                 return filename, init_py_filename         return None      def _find_file(self, d, filename):          """         Return the filename obtained when searching the directory 'd' for the         given 'filename', or None if no actual file exists for the filename.         """          filename = os.path.join(d, filename)         if os.path.exists(filename):             return filename         else:             return None      def load(self, name, return_leaf=0):          """         Load the module or package with the given 'name'. Return an object         referencing the loaded module or package, or None if no such module or         package exists.         """          if self.modules.has_key(name) and self.modules[name].loaded:             #print "Cached (%s)" % name             return self.modules[name]         if self.verbose:             print "Loading", name          # Split the name into path components, and try to find the uppermost in         # the search path.          path = name.split(".")         m = self.find_in_path(path[0])         if not m:             if self.verbose:                 print "Not found (%s)" % path[0]             return None # NOTE: Import error.         d, filename = m          # Either acquire a reference to an already-imported module, or load the         # module from a file.          top = module = self.load_from_file(filename, path[0])          # For hierarchical names, traverse each path component...          if len(path) > 1:             if not d:                 if self.verbose:                     print "No package (%s)" % filename                 return None # NOTE: Import error (package not found).             else:                 self.add_submodules(d, module)              path_so_far = path[:1]             for p in path[1:]:                 path_so_far.append(p)                  # Find the package or module concerned.                  m = self.find(d, p)                 if not m:                     if self.verbose:                         print "Not found (%s)" % p                     return None # NOTE: Import error.                 d, filename = m                 module_name = ".".join(path_so_far)                  # Either reference an imported module or load one from a file.                  submodule = self.load_from_file(filename, module_name)                  if d:                     self.add_submodules(d, module)                  # Store the submodule within its parent module.                  module.set_module(p, submodule)                 module = submodule          # Return either the deepest or the uppermost module.          if return_leaf:             return module         else:             return top      def load_from_file(self, name, module_name=None):          """         Load the module with the given 'name' (which may be a full module path).         """          if module_name is None:             module_name = "__main__"          module = self.add_module(module_name)         if not module.loaded and module not in self.loading:             self.loading.add(module)             #print "Parsing", name             module.parse(name)             #print "Done", name             self.loading.remove(module)             module.loaded = 1          # Record the module.          #print "Loaded", module_name, "with namespace", module.namespace.keys()         return module      def add_module(self, module_name):          """         Return the module with the given 'module_name', adding a new module         object if one does not already exist.         """          if not self.modules.has_key(module_name):             self.modules[module_name] = module = micropython.inspect.InspectedModule(module_name, self)             self.modules_ordered.append(module)         else:             module = self.modules[module_name]         return module      def add_submodules(self, pathname, module):          """         Work around insufficient __all__ declarations and examine the directory         with the given 'pathname', adding submodules to the given 'module'.         """          for filename in os.listdir(pathname):             submodule, ext = os.path.splitext(filename)             if ext not in ("", ".py"):                 continue             module.set_module(submodule, self.add_module(module.name + "." + submodule))  # vim: tabstop=4 expandtab shiftwidth=4