File Manager

X7ROOT File Manager

Current Path: /opt/alt/python27/lib64/python2.7/distutils

opt / alt / python27 / lib64 / python2.7 / distutils /

ðŸ“ ..
ðŸ“„ README(295 B)
ðŸ“„ __init__.py(236 B)
ðŸ“„ __init__.pyc(428 B)
ðŸ“„ __init__.pyo(428 B)
ðŸ“„ archive_util.py(8.03 KB)
ðŸ“„ archive_util.pyc(7.52 KB)
ðŸ“„ archive_util.pyo(7.52 KB)
ðŸ“„ bcppcompiler.py(14.59 KB)
ðŸ“„ bcppcompiler.pyc(7.81 KB)
ðŸ“„ bcppcompiler.pyo(7.81 KB)
ðŸ“„ ccompiler.py(45.63 KB)
ðŸ“„ ccompiler.pyc(36.72 KB)
ðŸ“„ ccompiler.pyo(36.58 KB)
ðŸ“„ cmd.py(18.82 KB)
ðŸ“„ cmd.pyc(16.88 KB)
ðŸ“„ cmd.pyo(16.88 KB)
ðŸ“ command
ðŸ“„ config.py(4.04 KB)
ðŸ“„ config.pyc(3.57 KB)
ðŸ“„ config.pyo(3.57 KB)
ðŸ“„ core.py(8.81 KB)
ðŸ“„ core.pyc(7.41 KB)
ðŸ“„ core.pyo(7.41 KB)
ðŸ“„ cygwinccompiler.py(17.32 KB)
ðŸ“„ cygwinccompiler.pyc(9.75 KB)
ðŸ“„ cygwinccompiler.pyo(9.75 KB)
ðŸ“„ debug.py(162 B)
ðŸ“„ debug.pyc(267 B)
ðŸ“„ debug.pyo(267 B)
ðŸ“„ dep_util.py(3.43 KB)
ðŸ“„ dep_util.pyc(3.16 KB)
ðŸ“„ dep_util.pyo(3.16 KB)
ðŸ“„ dir_util.py(7.68 KB)
ðŸ“„ dir_util.pyc(6.72 KB)
ðŸ“„ dir_util.pyo(6.72 KB)
ðŸ“„ dist.py(48.88 KB)
ðŸ“„ dist.pyc(39.11 KB)
ðŸ“„ dist.pyo(39.11 KB)
ðŸ“„ emxccompiler.py(11.65 KB)
ðŸ“„ emxccompiler.pyc(7.41 KB)
ðŸ“„ emxccompiler.pyo(7.41 KB)
ðŸ“„ errors.py(3.41 KB)
ðŸ“„ errors.pyc(6.39 KB)
ðŸ“„ errors.pyo(6.39 KB)
ðŸ“„ extension.py(10.65 KB)
ðŸ“„ extension.pyc(7.29 KB)
ðŸ“„ extension.pyo(7.07 KB)
ðŸ“„ fancy_getopt.py(17.53 KB)
ðŸ“„ fancy_getopt.pyc(11.94 KB)
ðŸ“„ fancy_getopt.pyo(11.77 KB)
ðŸ“„ file_util.py(7.94 KB)
ðŸ“„ file_util.pyc(6.66 KB)
ðŸ“„ file_util.pyo(6.66 KB)
ðŸ“„ filelist.py(12.39 KB)
ðŸ“„ filelist.pyc(10.72 KB)
ðŸ“„ filelist.pyo(10.72 KB)
ðŸ“„ log.py(1.65 KB)
ðŸ“„ log.pyc(2.87 KB)
ðŸ“„ log.pyo(2.87 KB)
ðŸ“„ msvc9compiler.py(30.28 KB)
ðŸ“„ msvc9compiler.pyc(21.39 KB)
ðŸ“„ msvc9compiler.pyo(21.32 KB)
ðŸ“„ msvccompiler.py(23.08 KB)
ðŸ“„ msvccompiler.pyc(17.44 KB)
ðŸ“„ msvccompiler.pyo(17.44 KB)
ðŸ“„ spawn.py(8.45 KB)
ðŸ“„ spawn.pyc(6.37 KB)
ðŸ“„ spawn.pyo(6.37 KB)
ðŸ“„ sysconfig.py(17.29 KB)
ðŸ“„ sysconfig.py.debug-build(17.21 KB)
ðŸ“„ sysconfig.pyc(13.29 KB)
ðŸ“„ sysconfig.pyo(13.29 KB)
ðŸ“„ text_file.py(12.14 KB)
ðŸ“„ text_file.pyc(9.18 KB)
ðŸ“„ text_file.pyo(9.18 KB)
ðŸ“„ unixccompiler.py(13.89 KB)
ðŸ“„ unixccompiler.py.distutils-rpath(13.36 KB)
ðŸ“„ unixccompiler.pyc(8.19 KB)
ðŸ“„ unixccompiler.pyo(8.19 KB)
ðŸ“„ util.py(17.81 KB)
ðŸ“„ util.pyc(14.23 KB)
ðŸ“„ util.pyo(14.23 KB)
ðŸ“„ version.py(11.17 KB)
ðŸ“„ version.pyc(7.23 KB)
ðŸ“„ version.pyo(7.23 KB)
ðŸ“„ versionpredicate.py(4.98 KB)
ðŸ“„ versionpredicate.pyc(5.5 KB)
ðŸ“„ versionpredicate.pyo(5.5 KB)

Editing: extension.py

"""distutils.extension

Provides the Extension class, used to describe C/C++ extension
modules in setup scripts."""

__revision__ = "$Id$"

import os, string, sys
from types import *

try:
    import warnings
except ImportError:
    warnings = None

# This class is really only used by the "build_ext" command, so it might
# make sense to put it in distutils.command.build_ext.  However, that
# module is already big enough, and I want to make this class a bit more
# complex to simplify some common cases ("foo" module in "foo.c") and do
# better error-checking ("foo.c" actually exists).
#
# Also, putting this in build_ext.py means every setup script would have to
# import that large-ish module (indirectly, through distutils.core) in
# order to do anything.

class Extension:
    """Just a collection of attributes that describes an extension
    module and everything needed to build it (hopefully in a portable
    way, but there are hooks that let you be as unportable as you need).

Instance attributes:
      name : string
        the full name of the extension, including any packages -- ie.
        *not* a filename or pathname, but Python dotted name
      sources : [string]
        list of source filenames, relative to the distribution root
        (where the setup script lives), in Unix form (slash-separated)
        for portability.  Source files may be C, C++, SWIG (.i),
        platform-specific resource files, or whatever else is recognized
        by the "build_ext" command as source for a Python extension.
      include_dirs : [string]
        list of directories to search for C/C++ header files (in Unix
        form for portability)
      define_macros : [(name : string, value : string|None)]
        list of macros to define; each macro is defined using a 2-tuple,
        where 'value' is either the string to define it to or None to
        define it without a particular value (equivalent of "#define
        FOO" in source or -DFOO on Unix C compiler command line)
      undef_macros : [string]
        list of macros to undefine explicitly
      library_dirs : [string]
        list of directories to search for C/C++ libraries at link time
      libraries : [string]
        list of library names (not filenames or paths) to link against
      runtime_library_dirs : [string]
        list of directories to search for C/C++ libraries at run time
        (for shared extensions, this is when the extension is loaded)
      extra_objects : [string]
        list of extra files to link with (eg. object files not implied
        by 'sources', static library that must be explicitly specified,
        binary resource files, etc.)
      extra_compile_args : [string]
        any extra platform- and compiler-specific information to use
        when compiling the source files in 'sources'.  For platforms and
        compilers where "command line" makes sense, this is typically a
        list of command-line arguments, but for other platforms it could
        be anything.
      extra_link_args : [string]
        any extra platform- and compiler-specific information to use
        when linking object files together to create the extension (or
        to create a new static Python interpreter).  Similar
        interpretation as for 'extra_compile_args'.
      export_symbols : [string]
        list of symbols to be exported from a shared extension.  Not
        used on all platforms, and not generally necessary for Python
        extensions, which typically export exactly one symbol: "init" +
        extension_name.
      swig_opts : [string]
        any extra options to pass to SWIG if a source file has the .i
        extension.
      depends : [string]
        list of files that the extension depends on
      language : string
        extension language (i.e. "c", "c++", "objc"). Will be detected
        from the source extensions if not provided.
    """

# When adding arguments to this constructor, be sure to update
    # setup_keywords in core.py.
    def __init__ (self, name, sources,
                  include_dirs=None,
                  define_macros=None,
                  undef_macros=None,
                  library_dirs=None,
                  libraries=None,
                  runtime_library_dirs=None,
                  extra_objects=None,
                  extra_compile_args=None,
                  extra_link_args=None,
                  export_symbols=None,
                  swig_opts = None,
                  depends=None,
                  language=None,
                  **kw                      # To catch unknown keywords
                 ):
        assert type(name) is StringType, "'name' must be a string"
        assert (type(sources) is ListType and
                map(type, sources) == [StringType]*len(sources)), \
                "'sources' must be a list of strings"

self.name = name
        self.sources = sources
        self.include_dirs = include_dirs or []
        self.define_macros = define_macros or []
        self.undef_macros = undef_macros or []
        self.library_dirs = library_dirs or []
        self.libraries = libraries or []
        self.runtime_library_dirs = runtime_library_dirs or []
        self.extra_objects = extra_objects or []
        self.extra_compile_args = extra_compile_args or []
        self.extra_link_args = extra_link_args or []
        self.export_symbols = export_symbols or []
        self.swig_opts = swig_opts or []
        self.depends = depends or []
        self.language = language

# If there are unknown keyword options, warn about them
        if len(kw):
            L = kw.keys() ; L.sort()
            L = map(repr, L)
            msg = "Unknown Extension options: " + string.join(L, ', ')
            if warnings is not None:
                warnings.warn(msg)
            else:
                sys.stderr.write(msg + '\n')
# class Extension

def read_setup_file (filename):
    from distutils.sysconfig import \
         parse_makefile, expand_makefile_vars, _variable_rx
    from distutils.text_file import TextFile
    from distutils.util import split_quoted

# First pass over the file to gather "VAR = VALUE" assignments.
    vars = parse_makefile(filename)

# Second pass to gobble up the real content: lines of the form
    #   <module> ... [<sourcefile> ...] [<cpparg> ...] [<library> ...]
    file = TextFile(filename,
                    strip_comments=1, skip_blanks=1, join_lines=1,
                    lstrip_ws=1, rstrip_ws=1)
    try:
        extensions = []

while 1:
            line = file.readline()
            if line is None:                # eof
                break
            if _variable_rx.match(line):    # VAR=VALUE, handled in first pass
                continue

if line[0] == line[-1] == "*":
                    file.warn("'%s' lines not handled yet" % line)
                    continue

#print "original line: " + line
            line = expand_makefile_vars(line, vars)
            words = split_quoted(line)
            #print "expanded line: " + line

# NB. this parses a slightly different syntax than the old
            # makesetup script: here, there must be exactly one extension per
            # line, and it must be the first word of the line.  I have no idea
            # why the old syntax supported multiple extensions per line, as
            # they all wind up being the same.

module = words[0]
            ext = Extension(module, [])
            append_next_word = None

for word in words[1:]:
                if append_next_word is not None:
                    append_next_word.append(word)
                    append_next_word = None
                    continue

suffix = os.path.splitext(word)[1]
                switch = word[0:2] ; value = word[2:]

if suffix in (".c", ".cc", ".cpp", ".cxx", ".c++", ".m", ".mm"):
                    # hmm, should we do something about C vs. C++ sources?
                    # or leave it up to the CCompiler implementation to
                    # worry about?
                    ext.sources.append(word)
                elif switch == "-I":
                    ext.include_dirs.append(value)
                elif switch == "-D":
                    equals = string.find(value, "=")
                    if equals == -1:        # bare "-DFOO" -- no value
                        ext.define_macros.append((value, None))
                    else:                   # "-DFOO=blah"
                        ext.define_macros.append((value[0:equals],
                                                  value[equals+2:]))
                elif switch == "-U":
                    ext.undef_macros.append(value)
                elif switch == "-C":        # only here 'cause makesetup has it!
                    ext.extra_compile_args.append(word)
                elif switch == "-l":
                    ext.libraries.append(value)
                elif switch == "-L":
                    ext.library_dirs.append(value)
                elif switch == "-R":
                    ext.runtime_library_dirs.append(value)
                elif word == "-rpath":
                    append_next_word = ext.runtime_library_dirs
                elif word == "-Xlinker":
                    append_next_word = ext.extra_link_args
                elif word == "-Xcompiler":
                    append_next_word = ext.extra_compile_args
                elif switch == "-u":
                    ext.extra_link_args.append(word)
                    if not value:
                        append_next_word = ext.extra_link_args
                elif word == "-Xcompiler":
                    append_next_word = ext.extra_compile_args
                elif switch == "-u":
                    ext.extra_link_args.append(word)
                    if not value:
                        append_next_word = ext.extra_link_args
                elif suffix in (".a", ".so", ".sl", ".o", ".dylib"):
                    # NB. a really faithful emulation of makesetup would
                    # append a .o file to extra_objects only if it
                    # had a slash in it; otherwise, it would s/.o/.c/
                    # and append it to sources.  Hmmmm.
                    ext.extra_objects.append(word)
                else:
                    file.warn("unrecognized argument '%s'" % word)

extensions.append(ext)
    finally:
        file.close()

#print "module:", module
        #print "source files:", source_files
        #print "cpp args:", cpp_args
        #print "lib args:", library_args

#extensions[module] = { 'sources': source_files,
        #                       'cpp_args': cpp_args,
        #                       'lib_args': library_args }

return extensions

# read_setup_file ()

X7ROOT File Manager

Editing: extension.py

Upload File

Create Folder