diff options
Diffstat (limited to 'debian/pyrex/pyrex-0.9.9/Pyrex/Compiler/Main.py')
| -rw-r--r-- | debian/pyrex/pyrex-0.9.9/Pyrex/Compiler/Main.py | 564 |
1 files changed, 0 insertions, 564 deletions
diff --git a/debian/pyrex/pyrex-0.9.9/Pyrex/Compiler/Main.py b/debian/pyrex/pyrex-0.9.9/Pyrex/Compiler/Main.py deleted file mode 100644 index 2769b771..00000000 --- a/debian/pyrex/pyrex-0.9.9/Pyrex/Compiler/Main.py +++ /dev/null @@ -1,564 +0,0 @@ -# -# Pyrex Top Level -# - -import os, re, sys -if sys.version_info[:2] < (2, 3): - print >>sys.stderr, "Sorry, Pyrex requires Python 2.3 or later" - sys.exit(1) - -import os -from time import time -import Builtin -import Code -import Errors -import Parsing -import Version -from Errors import PyrexError, CompileError, error -from Scanning import PyrexScanner -from Symtab import BuiltinScope, DefinitionScope, ImplementationScope -from Pyrex.Utils import set, replace_suffix, modification_time, \ - file_newer_than, castrate_file, map_suffix -from Filenames import cplus_suffix, pxd_suffixes, pyx_suffixes, \ - package_init_files, pyx_to_c_suffix - -verbose = 0 -debug_timestamps = 0 - -module_name_pattern = re.compile( - r"[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$") - -class Context: - # This class encapsulates the context needed for compiling - # one or more Pyrex implementation files along with their - # associated and imported declaration files. It holds - # the root of the module import namespace and the list - # of directories to search for include files. - # - # modules {string : DefinitionScope} - # include_directories [string] - - def __init__(self, include_directories): - self.modules = {"__builtin__" : Builtin.builtin_scope} - self.include_directories = include_directories - - def find_module(self, module_name, - relative_to = None, pos = None, need_pxd = 1): - # Finds and returns the module scope corresponding to - # the given relative or absolute module name. If this - # is the first time the module has been requested, finds - # the corresponding .pxd file and process it. - # If relative_to is not None, it must be a module scope, - # and the module will first be searched for relative to - # that module, provided its name is not a dotted name. - debug_find_module = 0 - if debug_find_module: - print "Context.find_module: module_name =", module_name, \ - "relative_to =", relative_to, "pos =", pos, "need_pxd =", need_pxd - scope = None - pxd_pathname = None - if "." not in module_name and relative_to: - if debug_find_module: - print "...trying relative import" - scope = relative_to.lookup_submodule(module_name) - if not scope: - qualified_name = relative_to.qualify_name(module_name) - pxd_pathname = self.find_pxd_file(qualified_name, pos) - if pxd_pathname: - scope = relative_to.find_submodule(module_name) - if not scope: - if debug_find_module: - print "...trying absolute import" - scope = self - for name in module_name.split("."): - scope = scope.find_submodule(name) - if debug_find_module: - print "...scope =", scope - if not scope.pxd_file_loaded: - if debug_find_module: - print "...pxd not loaded" - scope.pxd_file_loaded = 1 - if not pxd_pathname: - if debug_find_module: - print "...looking for pxd file" - pxd_pathname = self.find_pxd_file(module_name, pos) - if debug_find_module: - print "......found ", pxd_pathname - if not pxd_pathname and need_pxd: - error(pos, "Cannot find .pxd file for module '%s'" % module_name) - if pxd_pathname: - try: - if debug_find_module: - print "Context.find_module: Parsing", pxd_pathname - pxd_tree = self.parse(pxd_pathname, scope, pxd = 1) - pxd_tree.analyse_declarations(scope) - except CompileError: - pass - return scope - - def find_pxd_file(self, qualified_name, pos): - # Search include path for the .pxd file corresponding to the - # given fully-qualified module name. - # Will find either a dotted filename or a file in a - # package directory. If a source file position is given, - # the directory containing the source file is searched first - # for a dotted filename, and its containing package root - # directory is searched first for a non-dotted filename. - return self.search_package_directories(qualified_name, pxd_suffixes, pos) - - def find_pyx_file(self, qualified_name, pos): - # Search include path for the .pyx file corresponding to the - # given fully-qualified module name, as for find_pxd_file(). - return self.search_package_directories(qualified_name, pyx_suffixes, pos) - - def search_package_directories(self, qualified_name, suffixes, pos): - dotted_filenames = [qualified_name + suffix for suffix in suffixes] - if pos: - here = os.path.dirname(pos[0]) - for dotted_filename in dotted_filenames: - path = os.path.join(here, dotted_filename) - if os.path.exists(path): - return path - dirs = self.include_directories - if pos: - here = self.find_root_package_dir(pos[0]) - dirs = [here] + dirs - names = qualified_name.split(".") - package_names = names[:-1] - module_name = names[-1] - filenames = [module_name + suffix for suffix in suffixes] - for root in dirs: - for dotted_filename in dotted_filenames: - path = os.path.join(root, dotted_filename) - if os.path.exists(path): - return path - dir = self.descend_to_package_dir(root, package_names) - if dir: - for filename in filenames: - path = os.path.join(dir, filename) - if os.path.exists(path): - return path - for init_filename in package_init_files: - path = os.path.join(dir, module_name, init_filename) - if os.path.exists(path): - return path - - def find_root_package_dir(self, file_path): - # Given the full pathname of a source file, find the directory - # containing the top-level package that it ultimately belongs to. - dir = os.path.dirname(file_path) - while 1: - if not self.is_package_dir(dir): - return dir - parent = os.path.dirname(dir) - if parent == dir: - return dir - dir = parent - - def descend_to_package_dir(self, root_dir, package_names): - # Starting from the given root directory, look for a nested - # succession of package directories. Returns the full pathname - # of the innermost one, or None. - dir = root_dir - for name in package_names: - dir = os.path.join(dir, name) - if self.is_package_dir(dir): - return dir - - def is_package_dir(self, dir_path): - # Return true if the given directory is a package directory. - for filename in package_init_files: - path = os.path.join(dir_path, filename) - if os.path.exists(path): - return 1 - - def find_include_file(self, filename, pos): - # Search list of include directories for filename. - # Reports an error and returns None if not found. - path = self.search_include_directories(filename, pos) - if not path: - error(pos, "'%s' not found" % filename) - return path - - def search_include_directories(self, filename, pos): - # Search the list of include directories for the given - # file name. If a source file position is given, first - # searches the directory containing that file. Returns - # None if not found, but does not report an error. - dirs = self.include_directories - if pos: - here_dir = os.path.dirname(pos[0]) - dirs = [here_dir] + dirs - for dir in dirs: - path = os.path.join(dir, filename) - if os.path.exists(path): - return path - return None - - def lookup_submodule(self, name): - # Look up a top-level module. Returns None if not found. - return self.modules.get(name, None) - - def find_submodule(self, name): - # Find a top-level module, creating a new one if needed. - scope = self.lookup_submodule(name) - if not scope: - scope = DefinitionScope(name, - parent_module = None, context = self) - self.modules[name] = scope - return scope - - def parse(self, source_filename, scope, pxd): - # Parse the given source file and return a parse tree. - f = open(source_filename, "rU") - s = PyrexScanner(f, source_filename, scope = scope, context = self) - try: - tree = Parsing.p_module(s, pxd) - finally: - f.close() - if Errors.num_errors > 0: - raise CompileError - return tree - - def extract_module_name(self, path): - # Find fully_qualified module name from the full pathname - # of a source file. - dir, filename = os.path.split(path) - module_name, _ = os.path.splitext(filename) - if "." not in module_name: - if module_name == "__init__": - dir, module_name = os.path.split(dir) - names = [module_name] - while self.is_package_dir(dir): - parent, package_name = os.path.split(dir) - if parent == dir: - break - names.insert(0, package_name) - dir = parent - module_name = ".".join(names) - if not module_name_pattern.match(module_name): - raise CompileError((path, 0, 0), - "'%s' is not a valid module name" % module_name) - return module_name - - def dep_file_out_of_date(self, source_path): - dep_path = replace_suffix(source_path, ".dep") - if not os.path.exists(dep_path): - return 1 - dep_time = modification_time(dep_path) - return file_newer_than(source_path, dep_time) - - def c_file_out_of_date(self, source_path): - if debug_timestamps: - print "Checking whether", source_path, "is out of date" - c_path = map_suffix(source_path, pyx_to_c_suffix, ".c") - if not os.path.exists(c_path): - if debug_timestamps: - print "...yes, c file doesn't exist" - return 1 - c_time = modification_time(c_path) - if file_newer_than(source_path, c_time): - if debug_timestamps: - print "...yes, newer than c file" - return 1 - pos = [source_path] - module_name = self.extract_module_name(source_path) - pxd_path = self.find_pxd_file(module_name, pos) - if pxd_path and file_newer_than(pxd_path, c_time): - if debug_timestamps: - print "...yes, pxd file newer than c file" - return 1 - dep_path = replace_suffix(source_path, ".dep") - if not os.path.exists(dep_path): - if debug_timestamps: - print "...yes, dep file does not exist" - return 1 - for kind, name in self.read_dependency_file(source_path): - if kind == "cimport": - dep_path = self.find_pxd_file(name, pos) - elif kind == "include": - dep_path = self.search_include_directories(name, pos) - else: - continue - if dep_path and file_newer_than(dep_path, c_time): - if debug_timestamps: - print "...yes,", dep_path, "newer than c file" - return 1 - if debug_timestamps: - print "...no" - - def find_cimported_module_names(self, source_path): - for kind, name in self.read_dependency_file(source_path): - if kind == "cimport": - yield name - - def read_dependency_file(self, source_path): - dep_path = replace_suffix(source_path, ".dep") - if os.path.exists(dep_path): - f = open(dep_path, "rU") - for line in f.readlines(): - chunks = line.strip().split(" ", 1) - if len(chunks) == 2: - yield chunks - f.close() - - def compile(self, source, options = None): - # Compile a Pyrex implementation file in this context - # and return a CompilationResult. - if not options: - options = default_options - result = CompilationResult() - cwd = os.getcwd() - source = os.path.join(cwd, source) - if options.use_listing_file: - result.listing_file = replace_suffix(source, ".lis") - Errors.open_listing_file(result.listing_file, - echo_to_stderr = options.errors_to_stderr) - else: - Errors.open_listing_file(None) - if options.output_file: - result.c_file = os.path.join(cwd, options.output_file) - else: - if options.cplus: - result.c_file = replace_suffix(source, cplus_suffix) - else: - result.c_file = map_suffix(source, pyx_to_c_suffix, ".c") - module_name = self.extract_module_name(source) - initial_pos = (source, 1, 0) - def_scope = self.find_module(module_name, pos = initial_pos, need_pxd = 0) - imp_scope = ImplementationScope(def_scope) - errors_occurred = False - try: - tree = self.parse(source, imp_scope, pxd = 0) - tree.process_implementation(imp_scope, options, result) - except CompileError: - errors_occurred = True - Errors.close_listing_file() - result.num_errors = Errors.num_errors - if result.num_errors > 0: - errors_occurred = True - if errors_occurred and result.c_file: - try: - st = os.stat(source) - castrate_file(result.c_file, st) - except EnvironmentError: - pass - result.c_file = None - if result.c_file and not options.c_only and c_compile: - result.object_file = c_compile(result.c_file, - verbose_flag = options.show_version, - cplus = options.cplus) - if not options.obj_only and c_link: - result.extension_file = c_link(result.object_file, - extra_objects = options.objects, - verbose_flag = options.show_version, - cplus = options.cplus) - return result - -#------------------------------------------------------------------------ -# -# Main Python entry points -# -#------------------------------------------------------------------------ - -class CompilationOptions: - """ - Options to the Pyrex compiler: - - show_version boolean Display version number - use_listing_file boolean Generate a .lis file - errors_to_stderr boolean Echo errors to stderr when using .lis - include_path [string] Directories to search for include files - output_file string Name of generated .c file - generate_pxi boolean Generate .pxi file for public declarations - recursive boolean Recursively find and compile dependencies - timestamps boolean Only compile changed source files. If None, - defaults to true when recursive is true. - verbose boolean Always print source names being compiled - quiet boolean Don't print source names in recursive mode - - Following options are experimental and only used on MacOSX: - - c_only boolean Stop after generating C file (default) - obj_only boolean Stop after compiling to .o file - objects [string] Extra .o files to link with - cplus boolean Compile as c++ code - """ - - def __init__(self, defaults = None, c_compile = 0, c_link = 0, **kw): - self.include_path = [] - self.objects = [] - if defaults: - if isinstance(defaults, CompilationOptions): - defaults = defaults.__dict__ - else: - defaults = default_options - self.__dict__.update(defaults) - self.__dict__.update(kw) - if c_compile: - self.c_only = 0 - if c_link: - self.obj_only = 0 - - -class CompilationResult: - """ - Results from the Pyrex compiler: - - c_file string or None The generated C source file - h_file string or None The generated C header file - i_file string or None The generated .pxi file - api_file string or None The generated C API .h file - listing_file string or None File of error messages - object_file string or None Result of compiling the C file - extension_file string or None Result of linking the object file - num_errors integer Number of compilation errors - """ - - def __init__(self): - self.c_file = None - self.h_file = None - self.i_file = None - self.api_file = None - self.listing_file = None - self.object_file = None - self.extension_file = None - - -class CompilationResultSet(dict): - """ - Results from compiling multiple Pyrex source files. A mapping - from source file paths to CompilationResult instances. Also - has the following attributes: - - num_errors integer Total number of compilation errors - """ - - num_errors = 0 - - def add(self, source, result): - self[source] = result - self.num_errors += result.num_errors - - -def compile_single(source, options): - """ - compile_single(source, options) - - Compile the given Pyrex implementation file and return a CompilationResult. - Always compiles a single file; does not perform timestamp checking or - recursion. - """ - context = Context(options.include_path) - return context.compile(source, options) - -def compile_multiple(sources, options): - """ - compile_multiple(sources, options) - - Compiles the given sequence of Pyrex implementation files and returns - a CompilationResultSet. Performs timestamp checking and/or recursion - if these are specified in the options. - """ - sources = [os.path.abspath(source) for source in sources] - processed = set() - results = CompilationResultSet() - context = Context(options.include_path) - recursive = options.recursive - timestamps = options.timestamps - if timestamps is None: - timestamps = recursive - verbose = options.verbose or ((recursive or timestamps) and not options.quiet) - for source in sources: - if source not in processed: - if not timestamps or context.c_file_out_of_date(source): - if verbose: - print >>sys.stderr, "Compiling", source - result = context.compile(source, options) - results.add(source, result) - processed.add(source) - if recursive: - for module_name in context.find_cimported_module_names(source): - path = context.find_pyx_file(module_name, [source]) - if path: - sources.append(path) - else: - print >>sys.stderr, \ - "Cannot find .pyx file for cimported module '%s'" % module_name - return results - -def compile(source, options = None, c_compile = 0, c_link = 0, **kwds): - """ - compile(source [, options], [, <option> = <value>]...) - - Compile one or more Pyrex implementation files, with optional timestamp - checking and recursing on dependecies. The source argument may be a string - or a sequence of strings. If it is a string and no recursion or timestamp - checking is requested, a CompilationResult is returned, otherwise a - CompilationResultSet is returned. - """ - options = CompilationOptions(defaults = options, c_compile = c_compile, - c_link = c_link, **kwds) - if isinstance(source, basestring) and not options.timestamps \ - and not options.recursive: - return compile_single(source, options) - else: - return compile_multiple(source, options) - -#------------------------------------------------------------------------ -# -# Main command-line entry point -# -#------------------------------------------------------------------------ - -def main(command_line = 0): - args = sys.argv[1:] - any_failures = 0 - if command_line: - from CmdLine import parse_command_line - options, sources = parse_command_line(args) - else: - options = CompilationOptions(default_options) - sources = args - if options.show_version: - print >>sys.stderr, "Pyrex version %s" % Version.version - try: - result = compile(sources, options) - if result.num_errors > 0: - any_failures = 1 - except EnvironmentError, e: - print >>sys.stderr, e - any_failures = 1 - if any_failures: - sys.exit(1) - -#------------------------------------------------------------------------ -# -# Set the default options depending on the platform -# -#------------------------------------------------------------------------ - -default_options = dict( - show_version = 0, - use_listing_file = 0, - errors_to_stderr = 1, - c_only = 1, - obj_only = 1, - cplus = 0, - output_file = None, - generate_pxi = 0, - recursive = 0, - timestamps = None, - verbose = 0, - quiet = 0) - -if sys.platform == "mac": - from Pyrex.Mac.MacSystem import c_compile, c_link, CCompilerError - default_options['use_listing_file'] = 1 -elif sys.platform == "darwin": - from Pyrex.Mac.DarwinSystem import c_compile, c_link, CCompilerError -else: - c_compile = None - c_link = None - - |