# Top-level Makefile for Python

#

# As distributed, this file is called Makefile.pre.in; it is processed

# into the real Makefile by running the script ./configure, which

# replaces things like @spam@ with values appropriate for your system.

# This means that if you edit Makefile, your changes get lost the next

# time you run the configure script. Ideally, you can do:

#

# ./configure

# make

# make test

# make install

#

# If you have a previous version of Python installed that you don't

# want to overwrite, you can use "make altinstall" instead of "make

# install". Refer to the "Installing" section in the README file for

# additional details.

#

# See also the section "Build instructions" in the README file.

# === Variables set by makesetup ===

MODOBJS= _MODOBJS_

MODLIBS= _MODLIBS_

# === Variables set by configure

VERSION= 3.2

srcdir= .

CC= arm-linux-androideabi-gcc

CXX= arm-linux-androideabi-g++

MAINCC= $(CC)

LINKCC= $(PURIFY) $(MAINCC)

AR= arm-linux-androideabi-ar

RANLIB= arm-linux-androideabi-ranlib

SVNVERSION= echo Unversioned directory

SOABI= cpython-32m

LDVERSION= $(VERSION)$(ABIFLAGS)

HGVERSION=

HGTAG=

HGBRANCH=

GNULD= yes

# Shell used by make (some versions default to the login shell, which is bad)

SHELL= /bin/sh

# Use this to make a link between python$(VERSION) and python in $(BINDIR)

LN= ln

# Portable install script (configure doesn't always guess right)

INSTALL= /usr/bin/install -c

INSTALL_PROGRAM=${INSTALL}

INSTALL_SCRIPT= ${INSTALL}

INSTALL_DATA= ${INSTALL} -m 644

# Shared libraries must be installed with executable mode on some systems;

# rather than figuring out exactly which, we always give them executable mode.

# Also, making them read-only seems to be a good idea...

INSTALL_SHARED= ${INSTALL} -m 555

MAKESETUP= $(srcdir)/Modules/makesetup

# Compiler options

OPT= -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes

BASECFLAGS=

CONFIGURE_CFLAGS=

CONFIGURE_CPPFLAGS=

CONFIGURE_LDFLAGS=

# Avoid assigning CFLAGS, LDFLAGS, etc. so users can use them on the

# command line to append to these values without stomping the pre-set

# values.

PY_CFLAGS= $(BASECFLAGS) $(OPT) $(CONFIGURE_CFLAGS) $(CFLAGS) $(EXTRA_CFLAGS)

# Both CPPFLAGS and LDFLAGS need to contain the shell's value for setup.py to

# be able to build extension modules using the directories specified in the

# environment variables

PY_CPPFLAGS= -I. -IInclude -I$(srcdir)/Include $(CONFIGURE_CPPFLAGS) $(CPPFLAGS)

PY_LDFLAGS= $(CONFIGURE_LDFLAGS) $(LDFLAGS)

NO_AS_NEEDED= -Wl,--no-as-needed

LDLAST=

SGI_ABI=

CCSHARED= -fPIC

LINKFORSHARED= -Xlinker -export-dynamic

ARFLAGS= rc

# Extra C flags added for building the interpreter object files.

CFLAGSFORSHARED=$(CCSHARED)

# C flags used for building the interpreter object files

PY_CORE_CFLAGS= $(PY_CFLAGS) $(PY_CPPFLAGS) $(CFLAGSFORSHARED) -DPy_BUILD_CORE

# Machine-dependent subdirectories

MACHDEP= linux2

# Install prefix for architecture-independent files

prefix= /python

# Install prefix for architecture-dependent files

exec_prefix= ${prefix}

# Install prefix for data files

datarootdir= ${prefix}/share

# Expanded directories

BINDIR= ${exec_prefix}/bin

LIBDIR= ${exec_prefix}/lib

MANDIR= ${datarootdir}/man

INCLUDEDIR= ${prefix}/include

CONFINCLUDEDIR= $(exec_prefix)/include

SCRIPTDIR= $(prefix)/lib

ABIFLAGS= m

# Detailed destination directories

BINLIBDEST= $(LIBDIR)/python$(VERSION)

LIBDEST= $(SCRIPTDIR)/python$(VERSION)

INCLUDEPY= $(INCLUDEDIR)/python$(LDVERSION)

CONFINCLUDEPY= $(CONFINCLUDEDIR)/python$(LDVERSION)

# Symbols used for using shared libraries

SO= .cpython-32m.so

LDSHARED= $(CC) -shared $(PY_LDFLAGS)

BLDSHARED= $(CC) -shared $(PY_LDFLAGS)

LDCXXSHARED= $(CXX) -shared

DESTSHARED= $(BINLIBDEST)/lib-dynload

# Executable suffix (.exe on Windows and Mac OS X)

EXE=

BUILDEXE=

# Short name and location for Mac OS X Python framework

UNIVERSALSDK=

PYTHONFRAMEWORK=

PYTHONFRAMEWORKDIR= no-framework

PYTHONFRAMEWORKPREFIX=

PYTHONFRAMEWORKINSTALLDIR=

# Deployment target selected during configure, to be checked

# by distutils. The export statement is needed to ensure that the

# deployment target is active during build.

MACOSX_DEPLOYMENT_TARGET=

#export MACOSX_DEPLOYMENT_TARGET

# Options to enable prebinding (for fast startup prior to Mac OS X 10.3)

OTHER_LIBTOOL_OPT=

# Environment to run shared python without installed libraries

RUNSHARED= LD_LIBRARY_PATH=/home/robbie/python-for-android/python3-alpha/python3-src:

# Modes for directories, executables and data files created by the

# install process. Default to user-only-writable for all file types.

DIRMODE= 755

EXEMODE= 755

FILEMODE= 644

# configure script arguments

CONFIG_ARGS= '--host=arm-linux-androideabi' '--build=x86_64-linux-gnu' '--prefix=/python' '--enable-shared' 'build_alias=x86_64-linux-gnu' 'host_alias=arm-linux-androideabi' 'CC=arm-linux-androideabi-gcc'

# Subdirectories with code

SRCDIRS= Parser Grammar Objects Python Modules Mac

# Other subdirectories

SUBDIRSTOO= Include Lib Misc

# Files and directories to be distributed

CONFIGFILES= configure configure.in acconfig.h pyconfig.h.in Makefile.pre.in

DISTFILES= README ChangeLog $(CONFIGFILES)

DISTDIRS= $(SUBDIRS) $(SUBDIRSTOO) Ext-dummy

DIST= $(DISTFILES) $(DISTDIRS)

LIBRARY= libpython$(VERSION)$(ABIFLAGS).a

LDLIBRARY= libpython$(LDVERSION).so

BLDLIBRARY= -L. -lpython$(LDVERSION)

PY3LIBRARY= libpython3.so

DLLLIBRARY=

LDLIBRARYDIR=

INSTSONAME= libpython$(LDVERSION).so.1.0

LIBS= -ldl

LIBM= -lm

LIBC=

SYSLIBS= $(LIBM) $(LIBC)

SHLIBS= $(LIBS)

THREADOBJ= Python/thread.o

DLINCLDIR= .

DYNLOADFILE= dynload_shlib.o

MACHDEP_OBJS=

LIBOBJDIR= Python/

LIBOBJS=

PYTHON= python$(EXE)

BUILDPYTHON= python$(BUILDEXE)

# The task to run while instrument when building the profile-opt target

PROFILE_TASK= $(srcdir)/Tools/pybench/pybench.py -n 2 --with-gc --with-syscheck

#PROFILE_TASK= $(srcdir)/Lib/test/regrtest.py

# === Definitions added by makesetup ===

##########################################################################

# Modules

MODULE_OBJS= \

Modules/config.o \

Modules/getpath.o \

Modules/main.o \

Modules/gcmodule.o

# Used of signalmodule.o is not available

SIGNAL_OBJS=

IO_H= Modules/_io/_iomodule.h

IO_OBJS= \

Modules/_io/_iomodule.o \

Modules/_io/iobase.o \

Modules/_io/fileio.o \

Modules/_io/bufferedio.o \

Modules/_io/textio.o \

Modules/_io/bytesio.o \

Modules/_io/stringio.o

##########################################################################

# Grammar

GRAMMAR_H= $(srcdir)/Include/graminit.h

GRAMMAR_C= $(srcdir)/Python/graminit.c

GRAMMAR_INPUT= $(srcdir)/Grammar/Grammar

LIBFFI_INCLUDEDIR=

##########################################################################

# Parser

PGEN= Parser/pgen$(EXE)

POBJS= \

Parser/acceler.o \

Parser/grammar1.o \

Parser/listnode.o \

Parser/node.o \

Parser/parser.o \

Parser/parsetok.o \

Parser/bitset.o \

Parser/metagrammar.o \

Parser/firstsets.o \

Parser/grammar.o \

Parser/pgen.o

PARSER_OBJS= $(POBJS) Parser/myreadline.o Parser/tokenizer.o

PGOBJS= \

Objects/obmalloc.o \

Python/dynamic_annotations.o \

Python/mysnprintf.o \

Python/pyctype.o \

Parser/tokenizer_pgen.o \

Parser/printgrammar.o \

Parser/pgenmain.o

PARSER_HEADERS= \

Parser/parser.h \

Parser/tokenizer.h

PGENOBJS= $(PGENMAIN) $(POBJS) $(PGOBJS)

##########################################################################

# AST

AST_H_DIR= $(srcdir)/Include

AST_H= $(AST_H_DIR)/Python-ast.h

AST_C_DIR= $(srcdir)/Python

AST_C= $(AST_C_DIR)/Python-ast.c

AST_ASDL= $(srcdir)/Parser/Python.asdl

ASDLGEN_FILES= $(srcdir)/Parser/asdl.py $(srcdir)/Parser/asdl_c.py

# XXX Note that a build now requires Python exist before the build starts

ASDLGEN= @echo hg: no-repository, python: found! cannot run $(srcdir)/Parser/asdl_c.py # $(srcdir)/Parser/asdl_c.py

##########################################################################

# Python

OPCODETARGETS_H= \

$(srcdir)/Python/opcode_targets.h

OPCODETARGETGEN= \

$(srcdir)/Python/makeopcodetargets.py

OPCODETARGETGEN_FILES= \

$(OPCODETARGETGEN) $(srcdir)/Lib/opcode.py

PYTHON_OBJS= \

Python/_warnings.o \

Python/Python-ast.o \

Python/asdl.o \

Python/ast.o \

Python/bltinmodule.o \

Python/ceval.o \

Python/compile.o \

Python/codecs.o \

Python/dynamic_annotations.o \

Python/errors.o \

Python/frozen.o \

Python/frozenmain.o \

Python/future.o \

Python/getargs.o \

Python/getcompiler.o \

Python/getcopyright.o \

Python/getplatform.o \

Python/getversion.o \

Python/graminit.o \

Python/import.o \

Python/importdl.o \

Python/marshal.o \

Python/modsupport.o \

Python/mystrtoul.o \

Python/mysnprintf.o \

Python/peephole.o \

Python/pyarena.o \

Python/pyctype.o \

Python/pyfpe.o \

Python/pymath.o \

Python/pystate.o \

Python/pythonrun.o \

Python/pytime.o \

Python/structmember.o \

Python/symtable.o \

Python/sysmodule.o \

Python/traceback.o \

Python/getopt.o \

Python/pystrcmp.o \

Python/pystrtod.o \

Python/dtoa.o \

Python/formatter_unicode.o \

Python/fileutils.o \

Python/$(DYNLOADFILE) \

$(LIBOBJS) \

$(MACHDEP_OBJS) \

$(THREADOBJ)

##########################################################################

# Objects

OBJECT_OBJS= \

Objects/abstract.o \

Objects/boolobject.o \

Objects/bytes_methods.o \

Objects/bytearrayobject.o \

Objects/bytesobject.o \

Objects/cellobject.o \

Objects/classobject.o \

Objects/codeobject.o \

Objects/complexobject.o \

Objects/descrobject.o \

Objects/enumobject.o \

Objects/exceptions.o \

Objects/genobject.o \

Objects/fileobject.o \

Objects/floatobject.o \

Objects/frameobject.o \

Objects/funcobject.o \

Objects/iterobject.o \

Objects/listobject.o \

Objects/longobject.o \

Objects/dictobject.o \

Objects/memoryobject.o \

Objects/methodobject.o \

Objects/moduleobject.o \

Objects/object.o \

Objects/obmalloc.o \

Objects/capsule.o \

Objects/rangeobject.o \

Objects/setobject.o \

Objects/sliceobject.o \

Objects/structseq.o \

Objects/tupleobject.o \

Objects/typeobject.o \

Objects/unicodeobject.o \

Objects/unicodectype.o \

Objects/weakrefobject.o

##########################################################################

# objects that get linked into the Python library

LIBRARY_OBJS= \

Modules/getbuildinfo.o \

$(PARSER_OBJS) \

$(OBJECT_OBJS) \

$(PYTHON_OBJS) \

$(MODULE_OBJS) \

$(SIGNAL_OBJS) \

$(MODOBJS)

#########################################################################

# Rules

# Default target

all: build_all

build_all: $(BUILDPYTHON) oldsharedmods sharedmods gdbhooks Modules/_testembed

# Compile a binary with gcc profile guided optimization.

profile-opt:

@echo "Building with support for profile generation:"

$(MAKE) clean

$(MAKE) build_all_generate_profile

@echo "Running benchmark to generate profile data:"

$(MAKE) profile-removal

$(MAKE) run_profile_task

@echo "Rebuilding with profile guided optimizations:"

$(MAKE) clean

$(MAKE) build_all_use_profile

build_all_generate_profile:

$(MAKE) all CFLAGS="$(CFLAGS) -fprofile-generate" LIBS="$(LIBS) -lgcov"

run_profile_task:

./$(BUILDPYTHON) $(PROFILE_TASK)

build_all_use_profile:

$(MAKE) all CFLAGS="$(CFLAGS) -fprofile-use"

coverage:

@echo "Building with support for coverage checking:"

$(MAKE) clean

$(MAKE) all CFLAGS="$(CFLAGS) -O0 -pg -fprofile-arcs -ftest-coverage" LIBS="$(LIBS) -lgcov"

# Build the interpreter

$(BUILDPYTHON): Modules/python.o $(LIBRARY) $(LDLIBRARY) $(PY3LIBRARY)

$(LINKCC) $(PY_LDFLAGS) $(LINKFORSHARED) -o $@ Modules/python.o $(BLDLIBRARY) $(LIBS) $(MODLIBS) $(SYSLIBS) $(LDLAST)

platform: $(BUILDPYTHON)

$(RUNSHARED) ./$(BUILDPYTHON) -E -c 'import sys ; from sysconfig import get_platform ; print(get_platform()+"-"+sys.version[0:3])' >platform

# Build the shared modules

sharedmods: $(BUILDPYTHON)

@case $$MAKEFLAGS in \

*s*) $(RUNSHARED) CC='$(CC)' LDSHARED='$(BLDSHARED)' OPT='$(OPT)' $(HOSTPYTHON) -E $(srcdir)/setup.py -q build;; \

*) $(RUNSHARED) CC='$(CC)' LDSHARED='$(BLDSHARED)' OPT='$(OPT)' $(HOSTPYTHON) -E $(srcdir)/setup.py build;; \

esac

# Build static library

# avoid long command lines, same as LIBRARY_OBJS

$(LIBRARY): $(LIBRARY_OBJS)

-rm -f $@

$(AR) $(ARFLAGS) $@ Modules/getbuildinfo.o

$(AR) $(ARFLAGS) $@ $(PARSER_OBJS)

$(AR) $(ARFLAGS) $@ $(OBJECT_OBJS)

$(AR) $(ARFLAGS) $@ $(PYTHON_OBJS)

$(AR) $(ARFLAGS) $@ $(MODULE_OBJS) $(SIGNAL_OBJS)

$(AR) $(ARFLAGS) $@ $(MODOBJS)

$(RANLIB) $@

libpython$(LDVERSION).so: $(LIBRARY_OBJS)

if test $(INSTSONAME) != $(LDLIBRARY); then \

$(BLDSHARED) -Wl,-h$(INSTSONAME) -o $(INSTSONAME) $(LIBRARY_OBJS) $(MODLIBS) $(SHLIBS) $(LIBC) $(LIBM) $(LDLAST); \

$(LN) -f $(INSTSONAME) $@; \

else \

$(BLDSHARED) -o $@ $(LIBRARY_OBJS) $(MODLIBS) $(SHLIBS) $(LIBC) $(LIBM) $(LDLAST); \

fi

libpython3.so: libpython$(LDVERSION).so

$(BLDSHARED) $(NO_AS_NEEDED) -o $@ -Wl,-h$@ $^

libpython$(LDVERSION).dylib: $(LIBRARY_OBJS)

$(CC) -dynamiclib -Wl,-single_module $(PY_LDFLAGS) -undefined dynamic_lookup -Wl,-install_name,$(prefix)/lib/libpython$(LDVERSION).dylib -Wl,-compatibility_version,$(VERSION) -Wl,-current_version,$(VERSION) -o $@ $(LIBRARY_OBJS) $(SHLIBS) $(LIBC) $(LIBM) $(LDLAST); \

libpython$(VERSION).sl: $(LIBRARY_OBJS)

$(LDSHARED) -o $@ $(LIBRARY_OBJS) $(MODLIBS) $(SHLIBS) $(LIBC) $(LIBM) $(LDLAST)

# Copy up the gdb python hooks into a position where they can be automatically

# loaded by gdb during Lib/test/test_gdb.py

#

# Distributors are likely to want to install this somewhere else e.g. relative

# to the stripped DWARF data for the shared library.

gdbhooks: $(BUILDPYTHON)-gdb.py

SRC_GDB_HOOKS=$(srcdir)/Tools/gdb/libpython.py

$(BUILDPYTHON)-gdb.py: $(SRC_GDB_HOOKS)

$(INSTALL_DATA) $(SRC_GDB_HOOKS) $(BUILDPYTHON)-gdb.py

# This rule is here for OPENSTEP/Rhapsody/MacOSX. It builds a temporary

# minimal framework (not including the Lib directory and such) in the current

# directory.

RESSRCDIR=Mac/Resources/framework

$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK): \

$(LIBRARY) \

$(RESSRCDIR)/Info.plist

$(INSTALL) -d -m $(DIRMODE) $(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)

$(CC) -o $(LDLIBRARY) $(PY_LDFLAGS) -dynamiclib \

-all_load $(LIBRARY) -Wl,-single_module \

-install_name $(DESTDIR)$(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK) \

-compatibility_version $(VERSION) \

-current_version $(VERSION) \

-framework CoreFoundation $(LIBS);

$(INSTALL) -d -m $(DIRMODE) \

$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/Resources/English.lproj

$(INSTALL_DATA) $(RESSRCDIR)/Info.plist \

$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/Resources/Info.plist

$(LN) -fsn $(VERSION) $(PYTHONFRAMEWORKDIR)/Versions/Current

$(LN) -fsn Versions/Current/$(PYTHONFRAMEWORK) $(PYTHONFRAMEWORKDIR)/$(PYTHONFRAMEWORK)

$(LN) -fsn Versions/Current/Resources $(PYTHONFRAMEWORKDIR)/Resources

# This rule builds the Cygwin Python DLL and import library if configured

# for a shared core library; otherwise, this rule is a noop.

$(DLLLIBRARY) libpython$(VERSION).dll.a: $(LIBRARY_OBJS)

if test -n "$(DLLLIBRARY)"; then \

$(LDSHARED) -Wl,--out-implib=$@ -o $(DLLLIBRARY) $^ \

$(LIBS) $(MODLIBS) $(SYSLIBS) $(LDLAST); \

else true; \

fi

oldsharedmods: $(SHAREDMODS)

Makefile Modules/config.c: Makefile.pre \

$(srcdir)/Modules/config.c.in \

$(MAKESETUP) \

Modules/Setup.config \

Modules/Setup \

Modules/Setup.local

$(SHELL) $(MAKESETUP) -c $(srcdir)/Modules/config.c.in \

-s Modules \

Modules/Setup.config \

Modules/Setup.local \

Modules/Setup

@mv config.c Modules

@echo "The Makefile was updated, you may need to re-run make."

Modules/Setup: $(srcdir)/Modules/Setup.dist

@if test -f Modules/Setup; then \

echo "-----------------------------------------------"; \

echo "Modules/Setup.dist is newer than Modules/Setup;"; \

echo "check to make sure you have all the updates you"; \

echo "need in your Modules/Setup file."; \

echo "Usually, copying Modules/Setup.dist to Modules/Setup will work."; \

echo "-----------------------------------------------"; \

fi

Modules/_testembed: Modules/_testembed.o $(LIBRARY) $(LDLIBRARY) $(PY3LIBRARY)

$(LINKCC) $(PY_LDFLAGS) $(LINKFORSHARED) -o $@ Modules/_testembed.o $(BLDLIBRARY) $(LIBS) $(MODLIBS) $(SYSLIBS) $(LDLAST)

############################################################################

# Special rules for object files

Modules/getbuildinfo.o: $(PARSER_OBJS) \

$(OBJECT_OBJS) \

$(PYTHON_OBJS) \

$(MODULE_OBJS) \

$(SIGNAL_OBJS) \

$(MODOBJS) \

$(srcdir)/Modules/getbuildinfo.c

$(CC) -c $(PY_CORE_CFLAGS) \

-DSVNVERSION="\"`LC_ALL=C $(SVNVERSION)`\"" \

-DHGVERSION="\"`LC_ALL=C $(HGVERSION)`\"" \

-DHGTAG="\"`LC_ALL=C $(HGTAG)`\"" \

-DHGBRANCH="\"`LC_ALL=C $(HGBRANCH)`\"" \

-o $@ $(srcdir)/Modules/getbuildinfo.c

Modules/getpath.o: $(srcdir)/Modules/getpath.c Makefile

$(CC) -c $(PY_CORE_CFLAGS) -DPYTHONPATH='"$(PYTHONPATH)"' \

-DPREFIX='"$(prefix)"' \

-DEXEC_PREFIX='"$(exec_prefix)"' \

-DVERSION='"$(VERSION)"' \

-DVPATH='"$(VPATH)"' \

-o $@ $(srcdir)/Modules/getpath.c

Modules/python.o: $(srcdir)/Modules/python.c

$(MAINCC) -c $(PY_CORE_CFLAGS) -o $@ $(srcdir)/Modules/python.c

Python/dynload_shlib.o: $(srcdir)/Python/dynload_shlib.c Makefile

$(CC) -c $(PY_CORE_CFLAGS) \

-DSOABI='"$(SOABI)"' \

-o $@ $(srcdir)/Python/dynload_shlib.c

Python/sysmodule.o: $(srcdir)/Python/sysmodule.c Makefile

$(CC) -c $(PY_CORE_CFLAGS) \

-DABIFLAGS='"$(ABIFLAGS)"' \

-o $@ $(srcdir)/Python/sysmodule.c

$(IO_OBJS): $(IO_H)

# Use a stamp file to prevent make -j invoking pgen twice

$(GRAMMAR_H) $(GRAMMAR_C): Parser/pgen.stamp

Parser/pgen.stamp: $(PGEN) $(GRAMMAR_INPUT)

-@$(INSTALL) -d Include

$(HOSTPGEN) $(GRAMMAR_INPUT) $(GRAMMAR_H) $(GRAMMAR_C)

-touch Parser/pgen.stamp

$(PGEN): $(PGENOBJS)

$(CC) $(OPT) $(PY_LDFLAGS) $(PGENOBJS) $(LIBS) -o $(PGEN)

Parser/grammar.o: $(srcdir)/Parser/grammar.c \

$(srcdir)/Include/token.h \

$(srcdir)/Include/grammar.h

Parser/metagrammar.o: $(srcdir)/Parser/metagrammar.c

Parser/tokenizer_pgen.o: $(srcdir)/Parser/tokenizer.c

Parser/pgenmain.o: $(srcdir)/Include/parsetok.h

$(AST_H): $(AST_ASDL) $(ASDLGEN_FILES)

$(ASDLGEN) -h $(AST_H_DIR) $(AST_ASDL)

$(AST_C): $(AST_ASDL) $(ASDLGEN_FILES)

$(ASDLGEN) -c $(AST_C_DIR) $(AST_ASDL)

Python/compile.o Python/symtable.o Python/ast.o: $(GRAMMAR_H) $(AST_H)

Python/getplatform.o: $(srcdir)/Python/getplatform.c

$(CC) -c $(PY_CORE_CFLAGS) -DPLATFORM='"$(MACHDEP)"' -o $@ $(srcdir)/Python/getplatform.c

Python/importdl.o: $(srcdir)/Python/importdl.c

$(CC) -c $(PY_CORE_CFLAGS) -I$(DLINCLDIR) -o $@ $(srcdir)/Python/importdl.c

Objects/unicodectype.o: $(srcdir)/Objects/unicodectype.c \

$(srcdir)/Objects/unicodetype_db.h

BYTESTR_DEPS = \

$(srcdir)/Include/bytes_methods.h \

$(srcdir)/Objects/stringlib/count.h \

$(srcdir)/Objects/stringlib/ctype.h \

$(srcdir)/Objects/stringlib/eq.h \

$(srcdir)/Objects/stringlib/fastsearch.h \

$(srcdir)/Objects/stringlib/find.h \

$(srcdir)/Objects/stringlib/partition.h \

$(srcdir)/Objects/stringlib/split.h \

$(srcdir)/Objects/stringlib/stringdefs.h \

$(srcdir)/Objects/stringlib/string_format.h \

$(srcdir)/Objects/stringlib/transmogrify.h \

$(srcdir)/Objects/stringlib/unicodedefs.h \

$(srcdir)/Objects/stringlib/localeutil.h

Objects/bytesobject.o: $(srcdir)/Objects/bytesobject.c $(BYTESTR_DEPS)

Objects/bytearrayobject.o: $(srcdir)/Objects/bytearrayobject.c $(BYTESTR_DEPS)

Objects/unicodeobject.o: $(srcdir)/Objects/unicodeobject.c \

$(BYTESTR_DEPS)

$(OPCODETARGETS_H): $(OPCODETARGETGEN_FILES)

$(OPCODETARGETGEN) $(OPCODETARGETS_H)

Python/ceval.o: $(OPCODETARGETS_H) Python/ceval_gil.h

Python/formatter_unicode.o: $(srcdir)/Python/formatter_unicode.c \

$(BYTESTR_DEPS) \

$(srcdir)/Objects/stringlib/formatter.h

Objects/typeobject.o: $(srcdir)/Objects/typeslots.inc

$(srcdir)/Objects/typeslots.inc: $(srcdir)/Include/typeslots.h $(srcdir)/Objects/typeslots.py

$(PYTHON) $(srcdir)/Objects/typeslots.py < $(srcdir)/Include/typeslots.h > $(srcdir)/Objects/typeslots.inc

############################################################################

# Header files

PYTHON_HEADERS= \

Include/Python-ast.h \

Include/Python.h \

Include/abstract.h \

Include/asdl.h \

Include/ast.h \

Include/bltinmodule.h \

Include/bitset.h \

Include/boolobject.h \

Include/bytes_methods.h \

Include/bytearrayobject.h \

Include/bytesobject.h \

Include/cellobject.h \

Include/ceval.h \

Include/classobject.h \

Include/code.h \

Include/codecs.h \

Include/compile.h \

Include/complexobject.h \

Include/descrobject.h \

Include/dictobject.h \

Include/dtoa.h \

Include/dynamic_annotations.h \

Include/enumobject.h \

Include/errcode.h \

Include/eval.h \

Include/fileobject.h \

Include/fileutils.h \

Include/floatobject.h \

Include/frameobject.h \

Include/funcobject.h \

Include/genobject.h \

Include/import.h \

Include/intrcheck.h \

Include/iterobject.h \

Include/listobject.h \

Include/longintrepr.h \

Include/longobject.h \

Include/marshal.h \

Include/memoryobject.h \

Include/metagrammar.h \

Include/methodobject.h \

Include/modsupport.h \

Include/moduleobject.h \

Include/node.h \

Include/object.h \

Include/objimpl.h \

Include/opcode.h \

Include/osdefs.h \

Include/parsetok.h \

Include/patchlevel.h \

Include/pgen.h \

Include/pgenheaders.h \

Include/pyarena.h \

Include/pyatomic.h \

Include/pycapsule.h \

Include/pyctype.h \

Include/pydebug.h \

Include/pyerrors.h \

Include/pyfpe.h \

Include/pymath.h \

Include/pygetopt.h \

Include/pymem.h \

Include/pyport.h \

Include/pystate.h \

Include/pystrcmp.h \

Include/pystrtod.h \

Include/pythonrun.h \

Include/pythread.h \

Include/pytime.h \

Include/rangeobject.h \

Include/setobject.h \

Include/sliceobject.h \

Include/structmember.h \

Include/structseq.h \

Include/symtable.h \

Include/sysmodule.h \

Include/traceback.h \

Include/tupleobject.h \

Include/ucnhash.h \

Include/unicodeobject.h \

Include/warnings.h \

Include/weakrefobject.h \

pyconfig.h \

$(PARSER_HEADERS)

$(LIBRARY_OBJS) $(MODOBJS) Modules/python.o: $(PYTHON_HEADERS)

######################################################################

# Test the interpreter (twice, once without .pyc files, once with)

# In the past, we've had problems where bugs in the marshalling or

# elsewhere caused bytecode read from .pyc files to behave differently

# than bytecode generated directly from a .py source file. Sometimes

# the bytecode read from a .pyc file had the bug, somtimes the directly

# generated bytecode. This is sometimes a very shy bug needing a lot of

# sample data.

TESTOPTS= -l $(EXTRATESTOPTS)

TESTPROG= $(srcdir)/Lib/test/regrtest.py

TESTPYTHON= $(RUNSHARED) ./$(BUILDPYTHON) -Wd -E -bb $(TESTPYTHONOPTS)

test: all platform

-find $(srcdir)/Lib -name '*.py[co]' -print | xargs rm -f

-$(TESTPYTHON) $(TESTPROG) $(TESTOPTS)

$(TESTPYTHON) $(TESTPROG) $(TESTOPTS)

testall: all platform

-find $(srcdir)/Lib -name '*.py[co]' -print | xargs rm -f

$(TESTPYTHON) $(srcdir)/Lib/compileall.py

-find $(srcdir)/Lib -name '*.py[co]' -print | xargs rm -f

-$(TESTPYTHON) $(TESTPROG) -uall $(TESTOPTS)

$(TESTPYTHON) $(TESTPROG) -uall $(TESTOPTS)

# Run the unitests for both architectures in a Universal build on OSX

# Must be run on an Intel box.

testuniversal: all platform

if [ `arch` != 'i386' ];then \

echo "This can only be used on OSX/i386" ;\

exit 1 ;\

fi

-find $(srcdir)/Lib -name '*.py[co]' -print | xargs rm -f

-$(TESTPYTHON) $(TESTPROG) -uall $(TESTOPTS)

$(TESTPYTHON) $(TESTPROG) -uall $(TESTOPTS)

$(RUNSHARED) /usr/libexec/oah/translate ./$(BUILDPYTHON) -E $(TESTPROG) -uall $(TESTOPTS)

# Like testall, but with a single pass only

# run an optional script to include some information about the build environment

buildbottest: all platform

-@if which pybuildbot.identify >/dev/null 2>&1; then \

pybuildbot.identify "CC='$(CC)'" "CXX='$(CXX)'"; \

fi

$(TESTPYTHON) $(TESTPROG) -uall -rwW $(TESTOPTS)

QUICKTESTOPTS= $(TESTOPTS) -x test_subprocess test_io test_lib2to3 \

test_multibytecodec test_urllib2_localnet test_itertools \

test_multiprocessing test_mailbox test_socket test_poll \

test_select test_zipfile

quicktest: all platform

-find $(srcdir)/Lib -name '*.py[co]' -print | xargs rm -f

-$(TESTPYTHON) $(TESTPROG) $(QUICKTESTOPTS)

$(TESTPYTHON) $(TESTPROG) $(QUICKTESTOPTS)

MEMTESTOPTS= $(QUICKTESTOPTS) -x test_dl test___all__ test_fork1 \

test_longexp

memtest: all platform

-rm -f $(srcdir)/Lib/test/*.py[co]

-$(TESTPYTHON) $(TESTPROG) $(MEMTESTOPTS)

$(TESTPYTHON) $(TESTPROG) $(MEMTESTOPTS)

install: altinstall bininstall

altinstall: altbininstall libinstall inclinstall libainstall \

sharedinstall oldsharedinstall maninstall

# Install shared libraries enabled by Setup

DESTDIRS= $(exec_prefix) $(LIBDIR) $(BINLIBDEST) $(DESTSHARED)

oldsharedinstall: $(DESTSHARED) $(SHAREDMODS)

@for i in X $(SHAREDMODS); do \

if test $$i != X; then \

echo $(INSTALL_SHARED) $$i $(DESTSHARED)/`basename $$i`; \

$(INSTALL_SHARED) $$i $(DESTDIR)$(DESTSHARED)/`basename $$i`; \

fi; \

done

$(DESTSHARED):

@for i in $(DESTDIRS); \

do \

if test ! -d $(DESTDIR)$$i; then \

echo "Creating directory $$i"; \

$(INSTALL) -d -m $(DIRMODE) $(DESTDIR)$$i; \

else true; \

fi; \

done

# Install the interpreter with $(VERSION) affixed

# This goes into $(exec_prefix)

altbininstall: $(BUILDPYTHON)

@for i in $(BINDIR) $(LIBDIR); \

do \

if test ! -d $(DESTDIR)$$i; then \

echo "Creating directory $$i"; \

$(INSTALL) -d -m $(DIRMODE) $(DESTDIR)$$i; \

else true; \

fi; \

done

$(INSTALL_PROGRAM) $(BUILDPYTHON) $(DESTDIR)$(BINDIR)/python$(LDVERSION)$(EXE)

-if test "$(VERSION)" != "$(LDVERSION)"; then \

if test -f $(DESTDIR)$(BINDIR)/$(PYTHON)$(VERSION)$(EXE) -o -h $(DESTDIR)$(BINDIR)/$(PYTHON)$(VERSION)$(EXE); \

then rm -f $(DESTDIR)$(BINDIR)/python$(VERSION)$(EXE); \

fi; \

(cd $(DESTDIR)$(BINDIR); $(LN) python$(LDVERSION)$(EXE) python$(VERSION)$(EXE)); \

fi

if test -f $(LDLIBRARY); then \

if test -n "$(DLLLIBRARY)" ; then \

$(INSTALL_SHARED) $(DLLLIBRARY) $(DESTDIR)$(BINDIR); \

else \

$(INSTALL_SHARED) $(LDLIBRARY) $(DESTDIR)$(LIBDIR)/$(INSTSONAME); \

if test $(LDLIBRARY) != $(INSTSONAME); then \

(cd $(DESTDIR)$(LIBDIR); $(LN) -sf $(INSTSONAME) $(LDLIBRARY)) \

fi \

fi; \

if test -n "$(PY3LIBRARY)"; then \

$(INSTALL_SHARED) $(PY3LIBRARY) $(DESTDIR)$(LIBDIR)/$(PY3LIBRARY); \

fi; \

else true; \

fi

bininstall: altbininstall

-if test -f $(DESTDIR)$(BINDIR)/$(PYTHON)3$(EXE) -o -h $(DESTDIR)$(BINDIR)/$(PYTHON)3$(EXE); \

then rm -f $(DESTDIR)$(BINDIR)/$(PYTHON)3$(EXE); \

else true; \

fi

(cd $(DESTDIR)$(BINDIR); $(LN) python$(VERSION)$(EXE) $(PYTHON)3$(EXE))

-if test "$(VERSION)" != "$(LDVERSION)"; then \

rm -f $(DESTDIR)$(BINDIR)/python$(VERSION)-config; \

(cd $(DESTDIR)$(BINDIR); $(LN) -s python$(LDVERSION)-config python$(VERSION)-config); \

rm -f $(DESTDIR)$(LIBPC)/python-$(LDVERSION).pc; \

(cd $(DESTDIR)$(LIBPC); $(LN) -s python-$(VERSION).pc python-$(LDVERSION).pc); \

fi

-rm -f $(DESTDIR)$(BINDIR)/python3-config

(cd $(DESTDIR)$(BINDIR); $(LN) -s python$(VERSION)-config python3-config)

-rm -f $(DESTDIR)$(LIBPC)/python3.pc

(cd $(DESTDIR)$(LIBPC); $(LN) -s python-$(VERSION).pc python3.pc)

-rm -f $(DESTDIR)$(BINDIR)/idle3

(cd $(DESTDIR)$(BINDIR); $(LN) -s idle$(VERSION) idle3)

-rm -f $(DESTDIR)$(BINDIR)/pydoc3

(cd $(DESTDIR)$(BINDIR); $(LN) -s pydoc$(VERSION) pydoc3)

-rm -f $(DESTDIR)$(BINDIR)/2to3

(cd $(DESTDIR)$(BINDIR); $(LN) -s 2to3-$(VERSION) 2to3)

# Install the manual page

maninstall:

@for i in $(MANDIR) $(MANDIR)/man1; \

do \

if test ! -d $(DESTDIR)$$i; then \

echo "Creating directory $$i"; \

$(INSTALL) -d -m $(DIRMODE) $(DESTDIR)$$i; \

else true; \

fi; \

done

$(INSTALL_DATA) $(srcdir)/Misc/python.man \

$(DESTDIR)$(MANDIR)/man1/python$(VERSION).1

# Install the library

PLATDIR= plat-$(MACHDEP)

EXTRAPLATDIR= @EXTRAPLATDIR@

MACHDEPS= $(PLATDIR) $(EXTRAPLATDIR)

XMLLIBSUBDIRS= xml xml/dom xml/etree xml/parsers xml/sax

LIBSUBDIRS= tkinter tkinter/test tkinter/test/test_tkinter \

tkinter/test/test_ttk site-packages test \

test/capath test/data \

test/cjkencodings test/decimaltestdata test/xmltestdata test/subprocessdata \

test/tracedmodules test/encoded_modules \

concurrent concurrent/futures encodings \

email email/mime email/test email/test/data \

html json test/json_tests http dbm xmlrpc \

sqlite3 sqlite3/test \

logging csv wsgiref urllib \

lib2to3 lib2to3/fixes lib2to3/pgen2 lib2to3/tests \

lib2to3/tests/data lib2to3/tests/data/fixers lib2to3/tests/data/fixers/myfixes \

ctypes ctypes/test ctypes/macholib idlelib idlelib/Icons \

distutils distutils/command distutils/tests $(XMLLIBSUBDIRS) \

importlib importlib/test importlib/test/builtin \

importlib/test/extension importlib/test/frozen \

importlib/test/import_ importlib/test/source \

turtledemo \

multiprocessing multiprocessing/dummy \

unittest unittest/test \

curses pydoc_data $(MACHDEPS)

libinstall: build_all $(srcdir)/Lib/$(PLATDIR) $(srcdir)/Modules/xxmodule.c

@for i in $(SCRIPTDIR) $(LIBDEST); \

do \

if test ! -d $(DESTDIR)$$i; then \

echo "Creating directory $$i"; \

$(INSTALL) -d -m $(DIRMODE) $(DESTDIR)$$i; \

else true; \

fi; \

done

@for d in $(LIBSUBDIRS); \

do \

a=$(srcdir)/Lib/$$d; \

if test ! -d $$a; then continue; else true; fi; \

b=$(LIBDEST)/$$d; \

if test ! -d $(DESTDIR)$$b; then \

echo "Creating directory $$b"; \

$(INSTALL) -d -m $(DIRMODE) $(DESTDIR)$$b; \

else true; \

fi; \

done

@for i in $(srcdir)/Lib/*.py $(srcdir)/Lib/*.egg-info ; \

do \

if test -x $$i; then \

$(INSTALL_SCRIPT) $$i $(DESTDIR)$(LIBDEST); \

echo $(INSTALL_SCRIPT) $$i $(LIBDEST); \

else \

$(INSTALL_DATA) $$i $(DESTDIR)$(LIBDEST); \

echo $(INSTALL_DATA) $$i $(LIBDEST); \

fi; \

done

@for d in $(LIBSUBDIRS); \

do \

a=$(srcdir)/Lib/$$d; \

if test ! -d $$a; then continue; else true; fi; \

if test `ls $$a | wc -l` -lt 1; then continue; fi; \

b=$(LIBDEST)/$$d; \

for i in $$a/*; \

do \

case $$i in \

*CVS) ;; \

*.py[co]) ;; \

*.orig) ;; \

*~) ;; \

*) \

if test -d $$i; then continue; fi; \

if test -x $$i; then \

echo $(INSTALL_SCRIPT) $$i $$b; \

$(INSTALL_SCRIPT) $$i $(DESTDIR)$$b; \

else \

echo $(INSTALL_DATA) $$i $$b; \

$(INSTALL_DATA) $$i $(DESTDIR)$$b; \

fi;; \

esac; \

done; \

done

$(INSTALL_DATA) $(srcdir)/LICENSE $(DESTDIR)$(LIBDEST)/LICENSE.txt

if test -d $(DESTDIR)$(LIBDEST)/distutils/tests; then \

$(INSTALL_DATA) $(srcdir)/Modules/xxmodule.c \

$(DESTDIR)$(LIBDEST)/distutils/tests ; \

fi

-PYTHONPATH=$(DESTDIR)$(LIBDEST) $(RUNSHARED) \

./$(BUILDPYTHON) -Wi $(DESTDIR)$(LIBDEST)/compileall.py \

-d $(LIBDEST) -f \

-x 'bad_coding|badsyntax|site-packages|lib2to3/tests/data' \

$(DESTDIR)$(LIBDEST)

-PYTHONPATH=$(DESTDIR)$(LIBDEST) $(RUNSHARED) \

./$(BUILDPYTHON) -Wi -O $(DESTDIR)$(LIBDEST)/compileall.py \

-d $(LIBDEST) -f \

-x 'bad_coding|badsyntax|site-packages|lib2to3/tests/data' \