# 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=	@VERSION@

srcdir=		@srcdir@

VPATH=		@srcdir@

CC=		@CC@

CXX=		@CXX@

MAINCC=		@MAINCC@

LINKCC=		@LINKCC@

AR=		@AR@

RANLIB=		@RANLIB@

SVNVERSION=	@SVNVERSION@

# 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=	@INSTALL@

INSTALL_PROGRAM=@INSTALL_PROGRAM@

INSTALL_SCRIPT= @INSTALL_SCRIPT@

INSTALL_DATA=	@INSTALL_DATA@

# 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=		@OPT@

BASECFLAGS=	@BASECFLAGS@

CFLAGS=		$(BASECFLAGS) $(OPT) $(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

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

LDFLAGS=	@LDFLAGS@

LDLAST=		@LDLAST@

SGI_ABI=	@SGI_ABI@

CCSHARED=	@CCSHARED@

LINKFORSHARED=	@LINKFORSHARED@

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

CFLAGSFORSHARED=@CFLAGSFORSHARED@

# C flags used for building the interpreter object files

PY_CFLAGS=	$(CFLAGS) $(CPPFLAGS) $(CFLAGSFORSHARED) -DPy_BUILD_CORE

# Machine-dependent subdirectories

MACHDEP=	@MACHDEP@

# Install prefix for architecture-independent files

prefix=		@prefix@

# Install prefix for architecture-dependent files

exec_prefix=	@exec_prefix@

# Install prefix for data files

datarootdir=    @datarootdir@

# Expanded directories

BINDIR=		$(exec_prefix)/bin

LIBDIR=		$(exec_prefix)/lib

MANDIR=		@mandir@

INCLUDEDIR=	@includedir@

CONFINCLUDEDIR=	$(exec_prefix)/include

SCRIPTDIR=	$(prefix)/lib

# Detailed destination directories

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

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

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

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

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

# Symbols used for using shared libraries

SO=		@SO@

LDSHARED=	@LDSHARED@

BLDSHARED=	@BLDSHARED@

DESTSHARED=	$(BINLIBDEST)/lib-dynload

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

EXE=		@EXEEXT@

BUILDEXE=	@BUILDEXEEXT@

# Short name and location for Mac OS X Python framework

UNIVERSALSDK=@UNIVERSALSDK@

PYTHONFRAMEWORK=	@PYTHONFRAMEWORK@

PYTHONFRAMEWORKDIR=	@PYTHONFRAMEWORKDIR@

PYTHONFRAMEWORKPREFIX=	@PYTHONFRAMEWORKPREFIX@

PYTHONFRAMEWORKINSTALLDIR= @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=@CONFIGURE_MACOSX_DEPLOYMENT_TARGET@

@EXPORT_MACOSX_DEPLOYMENT_TARGET@export MACOSX_DEPLOYMENT_TARGET

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

OTHER_LIBTOOL_OPT=@OTHER_LIBTOOL_OPT@

# Environment to run shared python without installed libraries

RUNSHARED=       @RUNSHARED@

# 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=	@CONFIG_ARGS@

# Subdirectories with code

SRCDIRS= 	@SRCDIRS@

# Other subdirectories

SUBDIRSTOO=	Include Lib Misc Demo

# 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=	@LIBRARY@

LDLIBRARY=      @LDLIBRARY@

BLDLIBRARY=     @BLDLIBRARY@

DLLLIBRARY=	@DLLLIBRARY@

LDLIBRARYDIR=   @LDLIBRARYDIR@

INSTSONAME=	@INSTSONAME@

LIBS=		@LIBS@

LIBM=		@LIBM@

LIBC=		@LIBC@

SYSLIBS=	$(LIBM) $(LIBC)

SHLIBS=		@SHLIBS@

THREADOBJ=	@THREADOBJ@

DLINCLDIR=	@DLINCLDIR@

DYNLOADFILE=	@DYNLOADFILE@

MACHDEP_OBJS=	@MACHDEP_OBJS@

LIBOBJDIR=	Python/

LIBOBJS=	@LIBOBJS@

UNICODE_OBJS=   @UNICODE_OBJS@

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=	@SIGNAL_OBJS@

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

# Grammar

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

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

GRAMMAR_INPUT=	$(srcdir)/Grammar/Grammar

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

# 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/mysnprintf.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=	$(srcdir)/Parser/asdl_c.py

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

# Python

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/errors.o \

		Python/frozen.o \

		Python/frozenmain.o \

		Python/future.o \

		Python/getargs.o \

		Python/getcompiler.o \

		Python/getcopyright.o \

		Python/getmtime.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/pyfpe.o \

		Python/pymath.o \

		Python/pystate.o \

		Python/pythonrun.o \

		Python/structmember.o \

		Python/symtable.o \

		Python/sysmodule.o \

		Python/traceback.o \

		Python/getopt.o \

		Python/pystrcmp.o \

		Python/pystrtod.o \

		Python/formatter_unicode.o \

		Python/formatter_string.o \

		Python/$(DYNLOADFILE) \

		$(LIBOBJS) \

		$(MACHDEP_OBJS) \

		$(THREADOBJ)

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

# Objects

OBJECT_OBJS=	\

		Objects/abstract.o \

		Objects/boolobject.o \

		Objects/bufferobject.o \

		Objects/bytes_methods.o \

		Objects/bytearrayobject.o \

		Objects/cellobject.o \

		Objects/classobject.o \

		Objects/cobject.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/intobject.o \

		Objects/iterobject.o \

		Objects/listobject.o \

		Objects/longobject.o \

		Objects/dictobject.o \

		Objects/methodobject.o \

		Objects/moduleobject.o \

		Objects/object.o \

		Objects/obmalloc.o \

		Objects/rangeobject.o \

		Objects/setobject.o \

		Objects/sliceobject.o \

		Objects/stringobject.o \

		Objects/structseq.o \

		Objects/tupleobject.o \

		Objects/typeobject.o \

		Objects/weakrefobject.o \

		$(UNICODE_OBJS)

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

# 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

# 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)

		$(LINKCC) $(LDFLAGS) $(LINKFORSHARED) -o $@ \

			Modules/python.o \

			$(BLDLIBRARY) $(LIBS) $(MODLIBS) $(SYSLIBS) $(LDLAST)

platform: $(BUILDPYTHON)

	$(RUNSHARED) ./$(BUILDPYTHON) -E -c 'import sys ; from distutils.util 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)' ./$(BUILDPYTHON) -E $(srcdir)/setup.py -q build;; \

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

	esac

# Build static library

# avoid long command lines, same as LIBRARY_OBJS

$(LIBRARY): $(LIBRARY_OBJS)

	-rm -f $@

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

	$(AR) cr $@ $(PARSER_OBJS)

	$(AR) cr $@ $(OBJECT_OBJS)

	$(AR) cr $@ $(PYTHON_OBJS)

	$(AR) cr $@ $(MODULE_OBJS) $(SIGNAL_OBJS)

	$(AR) cr $@ $(MODOBJS)

	$(RANLIB) $@

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

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

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

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

	else\

		$(LDSHARED) $(LDFLAGS) -o $@ $(LIBRARY_OBJS) $(SHLIBS) $(LIBC) $(LIBM) $(LDLAST); \

	fi

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

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

# 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)

	if test "${UNIVERSALSDK}"; then \

		$(CC) -o $(LDLIBRARY) @UNIVERSAL_ARCH_FLAGS@ -dynamiclib \

			-isysroot "${UNIVERSALSDK}" \

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

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

			-compatibility_version $(VERSION) \

			-current_version $(VERSION); \

        else \

		/usr/bin/libtool -o $(LDLIBRARY) -dynamic $(OTHER_LIBTOOL_OPT) $(LIBRARY) \

			@LIBTOOL_CRUFT@ ;\

	fi

	$(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/Headers $(PYTHONFRAMEWORKDIR)/Headers

	$(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) $(LDFLAGS) -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

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

# 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_CFLAGS) -DSVNVERSION=\"`LC_ALL=C $(SVNVERSION)`\" -o $@ $(srcdir)/Modules/getbuildinfo.c

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

	$(CC) -c $(PY_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_CFLAGS) -o $@ $(srcdir)/Modules/python.c

$(GRAMMAR_H) $(GRAMMAR_C): $(PGEN) $(GRAMMAR_INPUT)

		-@$(INSTALL) -d Include

		-$(PGEN) $(GRAMMAR_INPUT) $(GRAMMAR_H) $(GRAMMAR_C)

$(PGEN):	$(PGENOBJS)

		$(CC) $(OPT) $(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