packages: python3/python3-lib64.patch, python3/python3.spec - more lib64 fi...
wrobell
wrobell at pld-linux.org
Sat May 21 22:33:58 CEST 2011
Author: wrobell Date: Sat May 21 20:33:58 2011 GMT
Module: packages Tag: HEAD
---- Log message:
- more lib64 fixes
- ver. 0.2
---- Files affected:
packages/python3:
python3-lib64.patch (1.6 -> 1.7) , python3.spec (1.46 -> 1.47)
---- Diffs:
================================================================
Index: packages/python3/python3-lib64.patch
diff -u packages/python3/python3-lib64.patch:1.6 packages/python3/python3-lib64.patch:1.7
--- packages/python3/python3-lib64.patch:1.6 Sat Apr 2 11:48:41 2011
+++ packages/python3/python3-lib64.patch Sat May 21 22:33:52 2011
@@ -1,8 +1,8 @@
-diff -Nur Python-2.5b2.orig/configure.in Python-2.5b2/configure.in
---- Python-2.5b2.orig/configure.in 2006-07-06 11:13:35.000000000 +0100
-+++ Python-2.5b2/configure.in 2006-07-12 17:42:51.000000000 +0100
-@@ -503,6 +503,41 @@
- ;;
+diff -Nur Python-3.2.orig//configure.in Python-3.2/configure.in
+--- Python-3.2.orig//configure.in 2011-02-19 08:58:23.000000000 +0000
++++ Python-3.2/configure.in 2011-05-21 21:16:30.000000000 +0100
+@@ -580,6 +580,41 @@
+ esac;;
esac
+AC_SUBST(ARCH)
@@ -43,10 +43,10 @@
AC_SUBST(LIBRARY)
AC_MSG_CHECKING(LIBRARY)
-diff -Nur Python-2.5b2.orig/Include/pythonrun.h Python-2.5b2/Include/pythonrun.h
---- Python-2.5b2.orig/Include/pythonrun.h 2006-04-03 07:26:32.000000000 +0100
-+++ Python-2.5b2/Include/pythonrun.h 2006-07-12 17:42:51.000000000 +0100
-@@ -107,6 +107,8 @@
+diff -Nur Python-3.2.orig//Include/pythonrun.h Python-3.2/Include/pythonrun.h
+--- Python-3.2.orig//Include/pythonrun.h 2010-12-27 01:49:31.000000000 +0000
++++ Python-3.2/Include/pythonrun.h 2011-05-21 21:16:30.000000000 +0100
+@@ -175,6 +175,8 @@
/* In their own files */
PyAPI_FUNC(const char *) Py_GetVersion(void);
PyAPI_FUNC(const char *) Py_GetPlatform(void);
@@ -55,8 +55,264 @@
PyAPI_FUNC(const char *) Py_GetCopyright(void);
PyAPI_FUNC(const char *) Py_GetCompiler(void);
PyAPI_FUNC(const char *) Py_GetBuildInfo(void);
---- Python-3.2/Lib/distutils/command/install.py.orig 2010-11-25 04:46:44.000000000 +0100
-+++ Python-3.2/Lib/distutils/command/install.py 2011-04-02 08:13:23.765733920 +0200
+diff -Nur Python-3.2.orig//Include/pythonrun.h.orig Python-3.2/Include/pythonrun.h.orig
+--- Python-3.2.orig//Include/pythonrun.h.orig 1970-01-01 01:00:00.000000000 +0100
++++ Python-3.2/Include/pythonrun.h.orig 2010-12-27 01:49:31.000000000 +0000
+@@ -0,0 +1,251 @@
++
++/* Interfaces to parse and execute pieces of python code */
++
++#ifndef Py_PYTHONRUN_H
++#define Py_PYTHONRUN_H
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#define PyCF_MASK (CO_FUTURE_DIVISION | CO_FUTURE_ABSOLUTE_IMPORT | \
++ CO_FUTURE_WITH_STATEMENT | CO_FUTURE_PRINT_FUNCTION | \
++ CO_FUTURE_UNICODE_LITERALS | CO_FUTURE_BARRY_AS_BDFL)
++#define PyCF_MASK_OBSOLETE (CO_NESTED)
++#define PyCF_SOURCE_IS_UTF8 0x0100
++#define PyCF_DONT_IMPLY_DEDENT 0x0200
++#define PyCF_ONLY_AST 0x0400
++#define PyCF_IGNORE_COOKIE 0x0800
++
++#ifndef Py_LIMITED_API
++typedef struct {
++ int cf_flags; /* bitmask of CO_xxx flags relevant to future */
++} PyCompilerFlags;
++#endif
++
++PyAPI_FUNC(void) Py_SetProgramName(wchar_t *);
++PyAPI_FUNC(wchar_t *) Py_GetProgramName(void);
++
++PyAPI_FUNC(void) Py_SetPythonHome(wchar_t *);
++PyAPI_FUNC(wchar_t *) Py_GetPythonHome(void);
++
++PyAPI_FUNC(void) Py_Initialize(void);
++PyAPI_FUNC(void) Py_InitializeEx(int);
++PyAPI_FUNC(void) Py_Finalize(void);
++PyAPI_FUNC(int) Py_IsInitialized(void);
++PyAPI_FUNC(PyThreadState *) Py_NewInterpreter(void);
++PyAPI_FUNC(void) Py_EndInterpreter(PyThreadState *);
++
++#ifndef Py_LIMITED_API
++PyAPI_FUNC(int) PyRun_SimpleStringFlags(const char *, PyCompilerFlags *);
++PyAPI_FUNC(int) PyRun_AnyFileFlags(FILE *, const char *, PyCompilerFlags *);
++PyAPI_FUNC(int) PyRun_AnyFileExFlags(
++ FILE *fp,
++ const char *filename, /* decoded from the filesystem encoding */
++ int closeit,
++ PyCompilerFlags *flags);
++PyAPI_FUNC(int) PyRun_SimpleFileExFlags(
++ FILE *fp,
++ const char *filename, /* decoded from the filesystem encoding */
++ int closeit,
++ PyCompilerFlags *flags);
++PyAPI_FUNC(int) PyRun_InteractiveOneFlags(
++ FILE *fp,
++ const char *filename, /* decoded from the filesystem encoding */
++ PyCompilerFlags *flags);
++PyAPI_FUNC(int) PyRun_InteractiveLoopFlags(
++ FILE *fp,
++ const char *filename, /* decoded from the filesystem encoding */
++ PyCompilerFlags *flags);
++
++PyAPI_FUNC(struct _mod *) PyParser_ASTFromString(
++ const char *s,
++ const char *filename, /* decoded from the filesystem encoding */
++ int start,
++ PyCompilerFlags *flags,
++ PyArena *arena);
++PyAPI_FUNC(struct _mod *) PyParser_ASTFromFile(
++ FILE *fp,
++ const char *filename, /* decoded from the filesystem encoding */
++ const char* enc,
++ int start,
++ char *ps1,
++ char *ps2,
++ PyCompilerFlags *flags,
++ int *errcode,
++ PyArena *arena);
++#endif
++
++#ifndef PyParser_SimpleParseString
++#define PyParser_SimpleParseString(S, B) \
++ PyParser_SimpleParseStringFlags(S, B, 0)
++#define PyParser_SimpleParseFile(FP, S, B) \
++ PyParser_SimpleParseFileFlags(FP, S, B, 0)
++#endif
++PyAPI_FUNC(struct _node *) PyParser_SimpleParseStringFlags(const char *, int,
++ int);
++PyAPI_FUNC(struct _node *) PyParser_SimpleParseFileFlags(FILE *, const char *,
++ int, int);
++
++#ifndef Py_LIMITED_API
++PyAPI_FUNC(PyObject *) PyRun_StringFlags(const char *, int, PyObject *,
++ PyObject *, PyCompilerFlags *);
++
++PyAPI_FUNC(PyObject *) PyRun_FileExFlags(
++ FILE *fp,
++ const char *filename, /* decoded from the filesystem encoding */
++ int start,
++ PyObject *globals,
++ PyObject *locals,
++ int closeit,
++ PyCompilerFlags *flags);
++#endif
++
++#ifdef Py_LIMITED_API
++PyAPI_FUNC(PyObject *) Py_CompileString(const char *, const char *, int);
++#else
++#define Py_CompileString(str, p, s) Py_CompileStringExFlags(str, p, s, NULL, -1)
++#define Py_CompileStringFlags(str, p, s, f) Py_CompileStringExFlags(str, p, s, f, -1)
++PyAPI_FUNC(PyObject *) Py_CompileStringExFlags(
++ const char *str,
++ const char *filename, /* decoded from the filesystem encoding */
++ int start,
++ PyCompilerFlags *flags,
++ int optimize);
++#endif
++PyAPI_FUNC(struct symtable *) Py_SymtableString(
++ const char *str,
++ const char *filename, /* decoded from the filesystem encoding */
++ int start);
++
++PyAPI_FUNC(void) PyErr_Print(void);
++PyAPI_FUNC(void) PyErr_PrintEx(int);
++PyAPI_FUNC(void) PyErr_Display(PyObject *, PyObject *, PyObject *);
++
++/* Py_PyAtExit is for the atexit module, Py_AtExit is for low-level
++ * exit functions.
++ */
++#ifndef Py_LIMITED_API
++PyAPI_FUNC(void) _Py_PyAtExit(void (*func)(void));
++#endif
++PyAPI_FUNC(int) Py_AtExit(void (*func)(void));
++
++PyAPI_FUNC(void) Py_Exit(int);
++
++/* Restore signals that the interpreter has called SIG_IGN on to SIG_DFL. */
++#ifndef Py_LIMITED_API
++PyAPI_FUNC(void) _Py_RestoreSignals(void);
++
++PyAPI_FUNC(int) Py_FdIsInteractive(FILE *, const char *);
++#endif
++
++/* Bootstrap */
++PyAPI_FUNC(int) Py_Main(int argc, wchar_t **argv);
++
++#ifndef Py_LIMITED_API
++/* Use macros for a bunch of old variants */
++#define PyRun_String(str, s, g, l) PyRun_StringFlags(str, s, g, l, NULL)
++#define PyRun_AnyFile(fp, name) PyRun_AnyFileExFlags(fp, name, 0, NULL)
++#define PyRun_AnyFileEx(fp, name, closeit) \
++ PyRun_AnyFileExFlags(fp, name, closeit, NULL)
++#define PyRun_AnyFileFlags(fp, name, flags) \
++ PyRun_AnyFileExFlags(fp, name, 0, flags)
++#define PyRun_SimpleString(s) PyRun_SimpleStringFlags(s, NULL)
++#define PyRun_SimpleFile(f, p) PyRun_SimpleFileExFlags(f, p, 0, NULL)
++#define PyRun_SimpleFileEx(f, p, c) PyRun_SimpleFileExFlags(f, p, c, NULL)
++#define PyRun_InteractiveOne(f, p) PyRun_InteractiveOneFlags(f, p, NULL)
++#define PyRun_InteractiveLoop(f, p) PyRun_InteractiveLoopFlags(f, p, NULL)
++#define PyRun_File(fp, p, s, g, l) \
++ PyRun_FileExFlags(fp, p, s, g, l, 0, NULL)
++#define PyRun_FileEx(fp, p, s, g, l, c) \
++ PyRun_FileExFlags(fp, p, s, g, l, c, NULL)
++#define PyRun_FileFlags(fp, p, s, g, l, flags) \
++ PyRun_FileExFlags(fp, p, s, g, l, 0, flags)
++#endif
++
++/* In getpath.c */
++PyAPI_FUNC(wchar_t *) Py_GetProgramFullPath(void);
++PyAPI_FUNC(wchar_t *) Py_GetPrefix(void);
++PyAPI_FUNC(wchar_t *) Py_GetExecPrefix(void);
++PyAPI_FUNC(wchar_t *) Py_GetPath(void);
++PyAPI_FUNC(void) Py_SetPath(const wchar_t *);
++#ifdef MS_WINDOWS
++int _Py_CheckPython3();
++#endif
++
++/* In their own files */
++PyAPI_FUNC(const char *) Py_GetVersion(void);
++PyAPI_FUNC(const char *) Py_GetPlatform(void);
++PyAPI_FUNC(const char *) Py_GetCopyright(void);
++PyAPI_FUNC(const char *) Py_GetCompiler(void);
++PyAPI_FUNC(const char *) Py_GetBuildInfo(void);
++#ifndef Py_LIMITED_API
++PyAPI_FUNC(const char *) _Py_svnversion(void);
++PyAPI_FUNC(const char *) Py_SubversionRevision(void);
++PyAPI_FUNC(const char *) Py_SubversionShortBranch(void);
++#endif
++
++/* Internal -- various one-time initializations */
++#ifndef Py_LIMITED_API
++PyAPI_FUNC(PyObject *) _PyBuiltin_Init(void);
++PyAPI_FUNC(PyObject *) _PySys_Init(void);
++PyAPI_FUNC(void) _PyImport_Init(void);
++PyAPI_FUNC(void) _PyExc_Init(void);
++PyAPI_FUNC(void) _PyImportHooks_Init(void);
++PyAPI_FUNC(int) _PyFrame_Init(void);
++PyAPI_FUNC(void) _PyFloat_Init(void);
++PyAPI_FUNC(int) PyByteArray_Init(void);
++#endif
++
++/* Various internal finalizers */
++#ifndef Py_LIMITED_API
++PyAPI_FUNC(void) _PyExc_Fini(void);
++PyAPI_FUNC(void) _PyImport_Fini(void);
++PyAPI_FUNC(void) PyMethod_Fini(void);
++PyAPI_FUNC(void) PyFrame_Fini(void);
++PyAPI_FUNC(void) PyCFunction_Fini(void);
++PyAPI_FUNC(void) PyDict_Fini(void);
++PyAPI_FUNC(void) PyTuple_Fini(void);
++PyAPI_FUNC(void) PyList_Fini(void);
++PyAPI_FUNC(void) PySet_Fini(void);
++PyAPI_FUNC(void) PyBytes_Fini(void);
++PyAPI_FUNC(void) PyByteArray_Fini(void);
++PyAPI_FUNC(void) PyFloat_Fini(void);
++PyAPI_FUNC(void) PyOS_FiniInterrupts(void);
++PyAPI_FUNC(void) _PyGC_Fini(void);
++#endif
++
++/* Stuff with no proper home (yet) */
++#ifndef Py_LIMITED_API
++PyAPI_FUNC(char *) PyOS_Readline(FILE *, FILE *, char *);
++#endif
++PyAPI_DATA(int) (*PyOS_InputHook)(void);
++PyAPI_DATA(char) *(*PyOS_ReadlineFunctionPointer)(FILE *, FILE *, char *);
++#ifndef Py_LIMITED_API
++PyAPI_DATA(PyThreadState*) _PyOS_ReadlineTState;
++#endif
++
++/* Stack size, in "pointers" (so we get extra safety margins
++ on 64-bit platforms). On a 32-bit platform, this translates
++ to a 8k margin. */
++#define PYOS_STACK_MARGIN 2048
++
++#if defined(WIN32) && !defined(MS_WIN64) && defined(_MSC_VER) && _MSC_VER >= 1300
++/* Enable stack checking under Microsoft C */
++#define USE_STACKCHECK
++#endif
++
++#ifdef USE_STACKCHECK
++/* Check that we aren't overflowing our stack */
++PyAPI_FUNC(int) PyOS_CheckStack(void);
++#endif
++
++/* Signals */
++typedef void (*PyOS_sighandler_t)(int);
++PyAPI_FUNC(PyOS_sighandler_t) PyOS_getsig(int);
++PyAPI_FUNC(PyOS_sighandler_t) PyOS_setsig(int, PyOS_sighandler_t);
++
++
++#ifdef __cplusplus
++}
++#endif
++#endif /* !Py_PYTHONRUN_H */
+diff -Nur Python-3.2.orig//Lib/distutils/command/install.py Python-3.2/Lib/distutils/command/install.py
+--- Python-3.2.orig//Lib/distutils/command/install.py 2010-11-25 03:46:44.000000000 +0000
++++ Python-3.2/Lib/distutils/command/install.py 2011-05-21 21:16:30.000000000 +0100
@@ -27,6 +27,8 @@
from site import USER_SITE
HAS_USER_SITE = True
@@ -83,10 +339,10 @@
'headers': '$base/include/python/$dist_name',
'scripts': '$base/bin',
'data' : '$base',
-diff -Nur Python-2.5b2.orig/Lib/distutils/sysconfig.py Python-2.5b2/Lib/distutils/sysconfig.py
---- Python-2.5b2.orig/Lib/distutils/sysconfig.py 2006-06-27 11:08:25.000000000 +0100
-+++ Python-2.5b2/Lib/distutils/sysconfig.py 2006-07-12 17:42:51.000000000 +0100
-@@ -99,8 +99,12 @@
+diff -Nur Python-3.2.orig//Lib/distutils/sysconfig.py Python-3.2/Lib/distutils/sysconfig.py
+--- Python-3.2.orig//Lib/distutils/sysconfig.py 2010-11-24 19:43:47.000000000 +0000
++++ Python-3.2/Lib/distutils/sysconfig.py 2011-05-21 21:16:30.000000000 +0100
+@@ -124,8 +124,12 @@
prefix = plat_specific and EXEC_PREFIX or PREFIX
if os.name == "posix":
@@ -100,10 +356,597 @@
if standard_lib:
return libpython
else:
-diff -Nur Python-2.5b2.orig/Lib/distutils/tests/test_install.py Python-2.5b2/Lib/distutils/tests/test_install.py
---- Python-2.5b2.orig/Lib/distutils/tests/test_install.py 2004-06-26 00:02:59.000000000 +0100
-+++ Python-2.5b2/Lib/distutils/tests/test_install.py 2006-07-12 17:42:51.000000000 +0100
-@@ -39,8 +39,9 @@
+diff -Nur Python-3.2.orig//Lib/distutils/sysconfig.py.orig Python-3.2/Lib/distutils/sysconfig.py.orig
+--- Python-3.2.orig//Lib/distutils/sysconfig.py.orig 1970-01-01 01:00:00.000000000 +0100
++++ Python-3.2/Lib/distutils/sysconfig.py.orig 2010-11-24 19:43:47.000000000 +0000
+@@ -0,0 +1,583 @@
++"""Provide access to Python's configuration information. The specific
++configuration variables available depend heavily on the platform and
++configuration. The values may be retrieved using
++get_config_var(name), and the list of variables is available via
++get_config_vars().keys(). Additional convenience functions are also
++available.
++
++Written by: Fred L. Drake, Jr.
++Email: <fdrake at acm.org>
++"""
++
++__revision__ = "$Id$"
++
++import os
++import re
++import sys
++
++from .errors import DistutilsPlatformError
++
++# These are needed in a couple of spots, so just compute them once.
++PREFIX = os.path.normpath(sys.prefix)
++EXEC_PREFIX = os.path.normpath(sys.exec_prefix)
++
++# Path to the base directory of the project. On Windows the binary may
++# live in project/PCBuild9. If we're dealing with an x64 Windows build,
++# it'll live in project/PCbuild/amd64.
++project_base = os.path.dirname(os.path.abspath(sys.executable))
++if os.name == "nt" and "pcbuild" in project_base[-8:].lower():
++ project_base = os.path.abspath(os.path.join(project_base, os.path.pardir))
++# PC/VS7.1
++if os.name == "nt" and "\\pc\\v" in project_base[-10:].lower():
++ project_base = os.path.abspath(os.path.join(project_base, os.path.pardir,
++ os.path.pardir))
++# PC/AMD64
++if os.name == "nt" and "\\pcbuild\\amd64" in project_base[-14:].lower():
++ project_base = os.path.abspath(os.path.join(project_base, os.path.pardir,
++ os.path.pardir))
++
++# python_build: (Boolean) if true, we're either building Python or
++# building an extension with an un-installed Python, so we use
++# different (hard-wired) directories.
++# Setup.local is available for Makefile builds including VPATH builds,
++# Setup.dist is available on Windows
++def _python_build():
++ for fn in ("Setup.dist", "Setup.local"):
++ if os.path.isfile(os.path.join(project_base, "Modules", fn)):
++ return True
++ return False
++python_build = _python_build()
++
++# Calculate the build qualifier flags if they are defined. Adding the flags
++# to the include and lib directories only makes sense for an installation, not
++# an in-source build.
++build_flags = ''
++try:
++ if not python_build:
++ build_flags = sys.abiflags
++except AttributeError:
++ # It's not a configure-based build, so the sys module doesn't have
++ # this attribute, which is fine.
++ pass
++
++def get_python_version():
++ """Return a string containing the major and minor Python version,
++ leaving off the patchlevel. Sample return values could be '1.5'
++ or '2.2'.
++ """
++ return sys.version[:3]
++
++
++def get_python_inc(plat_specific=0, prefix=None):
++ """Return the directory containing installed Python header files.
++
++ If 'plat_specific' is false (the default), this is the path to the
++ non-platform-specific header files, i.e. Python.h and so on;
++ otherwise, this is the path to platform-specific header files
++ (namely pyconfig.h).
++
++ If 'prefix' is supplied, use it instead of sys.prefix or
++ sys.exec_prefix -- i.e., ignore 'plat_specific'.
++ """
++ if prefix is None:
++ prefix = plat_specific and EXEC_PREFIX or PREFIX
++ if os.name == "posix":
++ if python_build:
++ # Assume the executable is in the build directory. The
++ # pyconfig.h file should be in the same directory. Since
++ # the build directory may not be the source directory, we
++ # must use "srcdir" from the makefile to find the "Include"
++ # directory.
++ base = os.path.dirname(os.path.abspath(sys.executable))
++ if plat_specific:
++ return base
++ else:
++ incdir = os.path.join(get_config_var('srcdir'), 'Include')
++ return os.path.normpath(incdir)
++ python_dir = 'python' + get_python_version() + build_flags
++ return os.path.join(prefix, "include", python_dir)
++ elif os.name == "nt":
++ return os.path.join(prefix, "include")
++ elif os.name == "os2":
++ return os.path.join(prefix, "Include")
++ else:
++ raise DistutilsPlatformError(
++ "I don't know where Python installs its C header files "
++ "on platform '%s'" % os.name)
++
++
++def get_python_lib(plat_specific=0, standard_lib=0, prefix=None):
++ """Return the directory containing the Python library (standard or
++ site additions).
++
++ If 'plat_specific' is true, return the directory containing
++ platform-specific modules, i.e. any module from a non-pure-Python
++ module distribution; otherwise, return the platform-shared library
++ directory. If 'standard_lib' is true, return the directory
++ containing standard Python library modules; otherwise, return the
++ directory for site-specific modules.
++
++ If 'prefix' is supplied, use it instead of sys.prefix or
++ sys.exec_prefix -- i.e., ignore 'plat_specific'.
++ """
++ if prefix is None:
++ prefix = plat_specific and EXEC_PREFIX or PREFIX
++
++ if os.name == "posix":
++ libpython = os.path.join(prefix,
++ "lib", "python" + get_python_version())
++ if standard_lib:
++ return libpython
++ else:
++ return os.path.join(libpython, "site-packages")
++ elif os.name == "nt":
++ if standard_lib:
++ return os.path.join(prefix, "Lib")
++ else:
++ if get_python_version() < "2.2":
++ return prefix
++ else:
++ return os.path.join(prefix, "Lib", "site-packages")
++ elif os.name == "os2":
++ if standard_lib:
++ return os.path.join(prefix, "Lib")
++ else:
++ return os.path.join(prefix, "Lib", "site-packages")
++ else:
++ raise DistutilsPlatformError(
++ "I don't know where Python installs its library "
++ "on platform '%s'" % os.name)
++
++
++def customize_compiler(compiler):
++ """Do any platform-specific customization of a CCompiler instance.
++
++ Mainly needed on Unix, so we can plug in the information that
++ varies across Unices and is stored in Python's Makefile.
++ """
++ if compiler.compiler_type == "unix":
++ (cc, cxx, opt, cflags, ccshared, ldshared, so_ext, ar, ar_flags) = \
++ get_config_vars('CC', 'CXX', 'OPT', 'CFLAGS',
++ 'CCSHARED', 'LDSHARED', 'SO', 'AR', 'ARFLAGS')
++
++ if 'CC' in os.environ:
++ cc = os.environ['CC']
++ if 'CXX' in os.environ:
++ cxx = os.environ['CXX']
++ if 'LDSHARED' in os.environ:
++ ldshared = os.environ['LDSHARED']
++ if 'CPP' in os.environ:
++ cpp = os.environ['CPP']
++ else:
++ cpp = cc + " -E" # not always
++ if 'LDFLAGS' in os.environ:
++ ldshared = ldshared + ' ' + os.environ['LDFLAGS']
++ if 'CFLAGS' in os.environ:
++ cflags = opt + ' ' + os.environ['CFLAGS']
++ ldshared = ldshared + ' ' + os.environ['CFLAGS']
++ if 'CPPFLAGS' in os.environ:
++ cpp = cpp + ' ' + os.environ['CPPFLAGS']
++ cflags = cflags + ' ' + os.environ['CPPFLAGS']
++ ldshared = ldshared + ' ' + os.environ['CPPFLAGS']
++ if 'AR' in os.environ:
++ ar = os.environ['AR']
++ if 'ARFLAGS' in os.environ:
++ archiver = ar + ' ' + os.environ['ARFLAGS']
++ else:
++ archiver = ar + ' ' + ar_flags
++
++ cc_cmd = cc + ' ' + cflags
++ compiler.set_executables(
++ preprocessor=cpp,
++ compiler=cc_cmd,
++ compiler_so=cc_cmd + ' ' + ccshared,
++ compiler_cxx=cxx,
++ linker_so=ldshared,
++ linker_exe=cc,
++ archiver=archiver)
++
++ compiler.shared_lib_extension = so_ext
++
++
++def get_config_h_filename():
++ """Return full pathname of installed pyconfig.h file."""
++ if python_build:
++ if os.name == "nt":
++ inc_dir = os.path.join(project_base, "PC")
++ else:
++ inc_dir = project_base
++ else:
++ inc_dir = get_python_inc(plat_specific=1)
++ if get_python_version() < '2.2':
++ config_h = 'config.h'
++ else:
++ # The name of the config.h file changed in 2.2
++ config_h = 'pyconfig.h'
++ return os.path.join(inc_dir, config_h)
++
++
++def get_makefile_filename():
++ """Return full pathname of installed Makefile from the Python build."""
++ if python_build:
++ return os.path.join(os.path.dirname(sys.executable), "Makefile")
++ lib_dir = get_python_lib(plat_specific=1, standard_lib=1)
++ config_file = 'config-{}{}'.format(get_python_version(), build_flags)
++ return os.path.join(lib_dir, config_file, 'Makefile')
++
++
++def parse_config_h(fp, g=None):
++ """Parse a config.h-style file.
++
++ A dictionary containing name/value pairs is returned. If an
++ optional dictionary is passed in as the second argument, it is
++ used instead of a new dictionary.
++ """
++ if g is None:
++ g = {}
++ define_rx = re.compile("#define ([A-Z][A-Za-z0-9_]+) (.*)\n")
++ undef_rx = re.compile("/[*] #undef ([A-Z][A-Za-z0-9_]+) [*]/\n")
++ #
++ while True:
++ line = fp.readline()
++ if not line:
++ break
++ m = define_rx.match(line)
++ if m:
++ n, v = m.group(1, 2)
++ try: v = int(v)
++ except ValueError: pass
++ g[n] = v
++ else:
++ m = undef_rx.match(line)
++ if m:
++ g[m.group(1)] = 0
++ return g
++
++
++# Regexes needed for parsing Makefile (and similar syntaxes,
++# like old-style Setup files).
++_variable_rx = re.compile("([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)")
++_findvar1_rx = re.compile(r"\$\(([A-Za-z][A-Za-z0-9_]*)\)")
++_findvar2_rx = re.compile(r"\${([A-Za-z][A-Za-z0-9_]*)}")
++
++def parse_makefile(fn, g=None):
++ """Parse a Makefile-style file.
++
++ A dictionary containing name/value pairs is returned. If an
++ optional dictionary is passed in as the second argument, it is
++ used instead of a new dictionary.
++ """
<<Diff was trimmed, longer than 597 lines>>
---- CVS-web:
http://cvs.pld-linux.org/cgi-bin/cvsweb.cgi/packages/python3/python3-lib64.patch?r1=1.6&r2=1.7&f=u
http://cvs.pld-linux.org/cgi-bin/cvsweb.cgi/packages/python3/python3.spec?r1=1.46&r2=1.47&f=u
More information about the pld-cvs-commit
mailing list